injectivejs 1.4.0 → 1.6.0

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

@@ -0,0 +1,1337 @@
+import { AssetPair, PriceAttestation, Params } from "./oracle";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseMsgRelayProviderPrices() {
+    return {
+        sender: "",
+        provider: "",
+        symbols: [],
+        prices: []
+    };
+}
+export const MsgRelayProviderPrices = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayProviderPrices",
+    aminoType: "oracle/MsgRelayProviderPrices",
+    is(o) {
+        return o && (o.$typeUrl === MsgRelayProviderPrices.typeUrl || typeof o.sender === "string" && typeof o.provider === "string" && Array.isArray(o.symbols) && (!o.symbols.length || typeof o.symbols[0] === "string") && Array.isArray(o.prices) && (!o.prices.length || typeof o.prices[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRelayProviderPrices.typeUrl || typeof o.sender === "string" && typeof o.provider === "string" && Array.isArray(o.symbols) && (!o.symbols.length || typeof o.symbols[0] === "string") && Array.isArray(o.prices) && (!o.prices.length || typeof o.prices[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.provider !== "") {
+            writer.uint32(18).string(message.provider);
+        }
+        for (const v of message.symbols) {
+            writer.uint32(26).string(v);
+        }
+        for (const v of message.prices) {
+            writer.uint32(34).string(v);
+        }
+        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 = createBaseMsgRelayProviderPrices();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.provider = reader.string();
+                    break;
+                case 3:
+                    message.symbols.push(reader.string());
+                    break;
+                case 4:
+                    message.prices.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRelayProviderPrices();
+        message.sender = object.sender ?? "";
+        message.provider = object.provider ?? "";
+        message.symbols = object.symbols?.map(e => e) || [];
+        message.prices = object.prices?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRelayProviderPrices();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.provider !== undefined && object.provider !== null) {
+            message.provider = object.provider;
+        }
+        message.symbols = object.symbols?.map(e => e) || [];
+        message.prices = object.prices?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.provider = message.provider === "" ? undefined : message.provider;
+        if (message.symbols) {
+            obj.symbols = message.symbols.map(e => e);
+        }
+        else {
+            obj.symbols = message.symbols;
+        }
+        if (message.prices) {
+            obj.prices = message.prices.map(e => e);
+        }
+        else {
+            obj.prices = message.prices;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayProviderPrices.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "oracle/MsgRelayProviderPrices",
+            value: MsgRelayProviderPrices.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRelayProviderPrices.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayProviderPrices.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayProviderPrices",
+            value: MsgRelayProviderPrices.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayProviderPrices.typeUrl, MsgRelayProviderPrices);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRelayProviderPrices.aminoType, MsgRelayProviderPrices.typeUrl);
+function createBaseMsgRelayProviderPricesResponse() {
+    return {};
+}
+export const MsgRelayProviderPricesResponse = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayProviderPricesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRelayProviderPricesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRelayProviderPricesResponse.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 = createBaseMsgRelayProviderPricesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRelayProviderPricesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRelayProviderPricesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayProviderPricesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRelayProviderPricesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayProviderPricesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayProviderPricesResponse",
+            value: MsgRelayProviderPricesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayProviderPricesResponse.typeUrl, MsgRelayProviderPricesResponse);
+function createBaseMsgRelayPriceFeedPrice() {
+    return {
+        sender: "",
+        base: [],
+        quote: [],
+        price: []
+    };
+}
+export const MsgRelayPriceFeedPrice = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayPriceFeedPrice",
+    aminoType: "oracle/MsgRelayPriceFeedPrice",
+    is(o) {
+        return o && (o.$typeUrl === MsgRelayPriceFeedPrice.typeUrl || typeof o.sender === "string" && Array.isArray(o.base) && (!o.base.length || typeof o.base[0] === "string") && Array.isArray(o.quote) && (!o.quote.length || typeof o.quote[0] === "string") && Array.isArray(o.price) && (!o.price.length || typeof o.price[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRelayPriceFeedPrice.typeUrl || typeof o.sender === "string" && Array.isArray(o.base) && (!o.base.length || typeof o.base[0] === "string") && Array.isArray(o.quote) && (!o.quote.length || typeof o.quote[0] === "string") && Array.isArray(o.price) && (!o.price.length || typeof o.price[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        for (const v of message.base) {
+            writer.uint32(18).string(v);
+        }
+        for (const v of message.quote) {
+            writer.uint32(26).string(v);
+        }
+        for (const v of message.price) {
+            writer.uint32(34).string(v);
+        }
+        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 = createBaseMsgRelayPriceFeedPrice();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.base.push(reader.string());
+                    break;
+                case 3:
+                    message.quote.push(reader.string());
+                    break;
+                case 4:
+                    message.price.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRelayPriceFeedPrice();
+        message.sender = object.sender ?? "";
+        message.base = object.base?.map(e => e) || [];
+        message.quote = object.quote?.map(e => e) || [];
+        message.price = object.price?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRelayPriceFeedPrice();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        message.base = object.base?.map(e => e) || [];
+        message.quote = object.quote?.map(e => e) || [];
+        message.price = object.price?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        if (message.base) {
+            obj.base = message.base.map(e => e);
+        }
+        else {
+            obj.base = message.base;
+        }
+        if (message.quote) {
+            obj.quote = message.quote.map(e => e);
+        }
+        else {
+            obj.quote = message.quote;
+        }
+        if (message.price) {
+            obj.price = message.price.map(e => e);
+        }
+        else {
+            obj.price = message.price;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayPriceFeedPrice.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "oracle/MsgRelayPriceFeedPrice",
+            value: MsgRelayPriceFeedPrice.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRelayPriceFeedPrice.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayPriceFeedPrice.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayPriceFeedPrice",
+            value: MsgRelayPriceFeedPrice.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayPriceFeedPrice.typeUrl, MsgRelayPriceFeedPrice);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRelayPriceFeedPrice.aminoType, MsgRelayPriceFeedPrice.typeUrl);
+function createBaseMsgRelayPriceFeedPriceResponse() {
+    return {};
+}
+export const MsgRelayPriceFeedPriceResponse = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayPriceFeedPriceResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRelayPriceFeedPriceResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRelayPriceFeedPriceResponse.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 = createBaseMsgRelayPriceFeedPriceResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRelayPriceFeedPriceResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRelayPriceFeedPriceResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayPriceFeedPriceResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRelayPriceFeedPriceResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayPriceFeedPriceResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayPriceFeedPriceResponse",
+            value: MsgRelayPriceFeedPriceResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayPriceFeedPriceResponse.typeUrl, MsgRelayPriceFeedPriceResponse);
+function createBaseMsgRelayBandRates() {
+    return {
+        relayer: "",
+        symbols: [],
+        rates: [],
+        resolveTimes: [],
+        requestIDs: []
+    };
+}
+export const MsgRelayBandRates = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayBandRates",
+    aminoType: "oracle/MsgRelayBandRates",
+    is(o) {
+        return o && (o.$typeUrl === MsgRelayBandRates.typeUrl || typeof o.relayer === "string" && Array.isArray(o.symbols) && (!o.symbols.length || typeof o.symbols[0] === "string") && Array.isArray(o.rates) && (!o.rates.length || typeof o.rates[0] === "bigint") && Array.isArray(o.resolveTimes) && (!o.resolveTimes.length || typeof o.resolveTimes[0] === "bigint") && Array.isArray(o.requestIDs) && (!o.requestIDs.length || typeof o.requestIDs[0] === "bigint"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRelayBandRates.typeUrl || typeof o.relayer === "string" && Array.isArray(o.symbols) && (!o.symbols.length || typeof o.symbols[0] === "string") && Array.isArray(o.rates) && (!o.rates.length || typeof o.rates[0] === "bigint") && Array.isArray(o.resolve_times) && (!o.resolve_times.length || typeof o.resolve_times[0] === "bigint") && Array.isArray(o.requestIDs) && (!o.requestIDs.length || typeof o.requestIDs[0] === "bigint"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.relayer !== "") {
+            writer.uint32(10).string(message.relayer);
+        }
+        for (const v of message.symbols) {
+            writer.uint32(18).string(v);
+        }
+        writer.uint32(26).fork();
+        for (const v of message.rates) {
+            writer.uint64(v);
+        }
+        writer.ldelim();
+        writer.uint32(34).fork();
+        for (const v of message.resolveTimes) {
+            writer.uint64(v);
+        }
+        writer.ldelim();
+        writer.uint32(42).fork();
+        for (const v of message.requestIDs) {
+            writer.uint64(v);
+        }
+        writer.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 = createBaseMsgRelayBandRates();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.relayer = reader.string();
+                    break;
+                case 2:
+                    message.symbols.push(reader.string());
+                    break;
+                case 3:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.rates.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.rates.push(reader.uint64());
+                    }
+                    break;
+                case 4:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.resolveTimes.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.resolveTimes.push(reader.uint64());
+                    }
+                    break;
+                case 5:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.requestIDs.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.requestIDs.push(reader.uint64());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRelayBandRates();
+        message.relayer = object.relayer ?? "";
+        message.symbols = object.symbols?.map(e => e) || [];
+        message.rates = object.rates?.map(e => BigInt(e.toString())) || [];
+        message.resolveTimes = object.resolveTimes?.map(e => BigInt(e.toString())) || [];
+        message.requestIDs = object.requestIDs?.map(e => BigInt(e.toString())) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRelayBandRates();
+        if (object.relayer !== undefined && object.relayer !== null) {
+            message.relayer = object.relayer;
+        }
+        message.symbols = object.symbols?.map(e => e) || [];
+        message.rates = object.rates?.map(e => BigInt(e)) || [];
+        message.resolveTimes = object.resolve_times?.map(e => BigInt(e)) || [];
+        message.requestIDs = object.requestIDs?.map(e => BigInt(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.relayer = message.relayer === "" ? undefined : message.relayer;
+        if (message.symbols) {
+            obj.symbols = message.symbols.map(e => e);
+        }
+        else {
+            obj.symbols = message.symbols;
+        }
+        if (message.rates) {
+            obj.rates = message.rates.map(e => e.toString());
+        }
+        else {
+            obj.rates = message.rates;
+        }
+        if (message.resolveTimes) {
+            obj.resolve_times = message.resolveTimes.map(e => e.toString());
+        }
+        else {
+            obj.resolve_times = message.resolveTimes;
+        }
+        if (message.requestIDs) {
+            obj.requestIDs = message.requestIDs.map(e => e.toString());
+        }
+        else {
+            obj.requestIDs = message.requestIDs;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayBandRates.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "oracle/MsgRelayBandRates",
+            value: MsgRelayBandRates.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRelayBandRates.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayBandRates.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayBandRates",
+            value: MsgRelayBandRates.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayBandRates.typeUrl, MsgRelayBandRates);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRelayBandRates.aminoType, MsgRelayBandRates.typeUrl);
+function createBaseMsgRelayBandRatesResponse() {
+    return {};
+}
+export const MsgRelayBandRatesResponse = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayBandRatesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRelayBandRatesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRelayBandRatesResponse.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 = createBaseMsgRelayBandRatesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRelayBandRatesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRelayBandRatesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayBandRatesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRelayBandRatesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayBandRatesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayBandRatesResponse",
+            value: MsgRelayBandRatesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayBandRatesResponse.typeUrl, MsgRelayBandRatesResponse);
+function createBaseMsgRelayCoinbaseMessages() {
+    return {
+        sender: "",
+        messages: [],
+        signatures: []
+    };
+}
+export const MsgRelayCoinbaseMessages = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayCoinbaseMessages",
+    aminoType: "oracle/MsgRelayCoinbaseMessages",
+    is(o) {
+        return o && (o.$typeUrl === MsgRelayCoinbaseMessages.typeUrl || typeof o.sender === "string" && Array.isArray(o.messages) && (!o.messages.length || o.messages[0] instanceof Uint8Array || typeof o.messages[0] === "string") && Array.isArray(o.signatures) && (!o.signatures.length || o.signatures[0] instanceof Uint8Array || typeof o.signatures[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRelayCoinbaseMessages.typeUrl || typeof o.sender === "string" && Array.isArray(o.messages) && (!o.messages.length || o.messages[0] instanceof Uint8Array || typeof o.messages[0] === "string") && Array.isArray(o.signatures) && (!o.signatures.length || o.signatures[0] instanceof Uint8Array || typeof o.signatures[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        for (const v of message.messages) {
+            writer.uint32(18).bytes(v);
+        }
+        for (const v of message.signatures) {
+            writer.uint32(26).bytes(v);
+        }
+        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 = createBaseMsgRelayCoinbaseMessages();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.messages.push(reader.bytes());
+                    break;
+                case 3:
+                    message.signatures.push(reader.bytes());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRelayCoinbaseMessages();
+        message.sender = object.sender ?? "";
+        message.messages = object.messages?.map(e => e) || [];
+        message.signatures = object.signatures?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRelayCoinbaseMessages();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        message.messages = object.messages?.map(e => bytesFromBase64(e)) || [];
+        message.signatures = object.signatures?.map(e => bytesFromBase64(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        if (message.messages) {
+            obj.messages = message.messages.map(e => base64FromBytes(e));
+        }
+        else {
+            obj.messages = message.messages;
+        }
+        if (message.signatures) {
+            obj.signatures = message.signatures.map(e => base64FromBytes(e));
+        }
+        else {
+            obj.signatures = message.signatures;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayCoinbaseMessages.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "oracle/MsgRelayCoinbaseMessages",
+            value: MsgRelayCoinbaseMessages.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRelayCoinbaseMessages.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayCoinbaseMessages.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayCoinbaseMessages",
+            value: MsgRelayCoinbaseMessages.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayCoinbaseMessages.typeUrl, MsgRelayCoinbaseMessages);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRelayCoinbaseMessages.aminoType, MsgRelayCoinbaseMessages.typeUrl);
+function createBaseMsgRelayCoinbaseMessagesResponse() {
+    return {};
+}
+export const MsgRelayCoinbaseMessagesResponse = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayCoinbaseMessagesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRelayCoinbaseMessagesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRelayCoinbaseMessagesResponse.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 = createBaseMsgRelayCoinbaseMessagesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRelayCoinbaseMessagesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRelayCoinbaseMessagesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayCoinbaseMessagesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRelayCoinbaseMessagesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayCoinbaseMessagesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayCoinbaseMessagesResponse",
+            value: MsgRelayCoinbaseMessagesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayCoinbaseMessagesResponse.typeUrl, MsgRelayCoinbaseMessagesResponse);
+function createBaseMsgRelayStorkPrices() {
+    return {
+        sender: "",
+        assetPairs: []
+    };
+}
+export const MsgRelayStorkPrices = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayStorkPrices",
+    is(o) {
+        return o && (o.$typeUrl === MsgRelayStorkPrices.typeUrl || typeof o.sender === "string" && Array.isArray(o.assetPairs) && (!o.assetPairs.length || AssetPair.is(o.assetPairs[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRelayStorkPrices.typeUrl || typeof o.sender === "string" && Array.isArray(o.asset_pairs) && (!o.asset_pairs.length || AssetPair.isAmino(o.asset_pairs[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        for (const v of message.assetPairs) {
+            AssetPair.encode(v, 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 = createBaseMsgRelayStorkPrices();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.assetPairs.push(AssetPair.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRelayStorkPrices();
+        message.sender = object.sender ?? "";
+        message.assetPairs = object.assetPairs?.map(e => AssetPair.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRelayStorkPrices();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        message.assetPairs = object.asset_pairs?.map(e => AssetPair.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        if (message.assetPairs) {
+            obj.asset_pairs = message.assetPairs.map(e => e ? AssetPair.toAmino(e) : undefined);
+        }
+        else {
+            obj.asset_pairs = message.assetPairs;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayStorkPrices.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRelayStorkPrices.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayStorkPrices.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayStorkPrices",
+            value: MsgRelayStorkPrices.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayStorkPrices.typeUrl, MsgRelayStorkPrices);
+function createBaseMsgRelayStorkPricesResponse() {
+    return {};
+}
+export const MsgRelayStorkPricesResponse = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayStorkPricesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRelayStorkPricesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRelayStorkPricesResponse.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 = createBaseMsgRelayStorkPricesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRelayStorkPricesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRelayStorkPricesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayStorkPricesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRelayStorkPricesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayStorkPricesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayStorkPricesResponse",
+            value: MsgRelayStorkPricesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayStorkPricesResponse.typeUrl, MsgRelayStorkPricesResponse);
+function createBaseMsgRequestBandIBCRates() {
+    return {
+        sender: "",
+        requestId: BigInt(0)
+    };
+}
+export const MsgRequestBandIBCRates = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRequestBandIBCRates",
+    aminoType: "oracle/MsgRequestBandIBCRates",
+    is(o) {
+        return o && (o.$typeUrl === MsgRequestBandIBCRates.typeUrl || typeof o.sender === "string" && typeof o.requestId === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRequestBandIBCRates.typeUrl || typeof o.sender === "string" && typeof o.request_id === "bigint");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.requestId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.requestId);
+        }
+        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 = createBaseMsgRequestBandIBCRates();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.requestId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRequestBandIBCRates();
+        message.sender = object.sender ?? "";
+        message.requestId = object.requestId !== undefined && object.requestId !== null ? BigInt(object.requestId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRequestBandIBCRates();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.request_id !== undefined && object.request_id !== null) {
+            message.requestId = BigInt(object.request_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.request_id = message.requestId !== BigInt(0) ? message.requestId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRequestBandIBCRates.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "oracle/MsgRequestBandIBCRates",
+            value: MsgRequestBandIBCRates.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRequestBandIBCRates.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRequestBandIBCRates.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRequestBandIBCRates",
+            value: MsgRequestBandIBCRates.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRequestBandIBCRates.typeUrl, MsgRequestBandIBCRates);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRequestBandIBCRates.aminoType, MsgRequestBandIBCRates.typeUrl);
+function createBaseMsgRequestBandIBCRatesResponse() {
+    return {};
+}
+export const MsgRequestBandIBCRatesResponse = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRequestBandIBCRatesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRequestBandIBCRatesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRequestBandIBCRatesResponse.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 = createBaseMsgRequestBandIBCRatesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRequestBandIBCRatesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRequestBandIBCRatesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRequestBandIBCRatesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRequestBandIBCRatesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRequestBandIBCRatesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRequestBandIBCRatesResponse",
+            value: MsgRequestBandIBCRatesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRequestBandIBCRatesResponse.typeUrl, MsgRequestBandIBCRatesResponse);
+function createBaseMsgRelayPythPrices() {
+    return {
+        sender: "",
+        priceAttestations: []
+    };
+}
+export const MsgRelayPythPrices = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayPythPrices",
+    aminoType: "oracle/MsgRelayPythPrices",
+    is(o) {
+        return o && (o.$typeUrl === MsgRelayPythPrices.typeUrl || typeof o.sender === "string" && Array.isArray(o.priceAttestations) && (!o.priceAttestations.length || PriceAttestation.is(o.priceAttestations[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRelayPythPrices.typeUrl || typeof o.sender === "string" && Array.isArray(o.price_attestations) && (!o.price_attestations.length || PriceAttestation.isAmino(o.price_attestations[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        for (const v of message.priceAttestations) {
+            PriceAttestation.encode(v, 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 = createBaseMsgRelayPythPrices();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.priceAttestations.push(PriceAttestation.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRelayPythPrices();
+        message.sender = object.sender ?? "";
+        message.priceAttestations = object.priceAttestations?.map(e => PriceAttestation.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRelayPythPrices();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        message.priceAttestations = object.price_attestations?.map(e => PriceAttestation.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        if (message.priceAttestations) {
+            obj.price_attestations = message.priceAttestations.map(e => e ? PriceAttestation.toAmino(e) : undefined);
+        }
+        else {
+            obj.price_attestations = message.priceAttestations;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayPythPrices.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "oracle/MsgRelayPythPrices",
+            value: MsgRelayPythPrices.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRelayPythPrices.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayPythPrices.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayPythPrices",
+            value: MsgRelayPythPrices.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayPythPrices.typeUrl, MsgRelayPythPrices);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRelayPythPrices.aminoType, MsgRelayPythPrices.typeUrl);
+function createBaseMsgRelayPythPricesResponse() {
+    return {};
+}
+export const MsgRelayPythPricesResponse = {
+    typeUrl: "/injective.oracle.v1beta1.MsgRelayPythPricesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRelayPythPricesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRelayPythPricesResponse.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 = createBaseMsgRelayPythPricesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRelayPythPricesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRelayPythPricesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRelayPythPricesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRelayPythPricesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRelayPythPricesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.v1beta1.MsgRelayPythPricesResponse",
+            value: MsgRelayPythPricesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRelayPythPricesResponse.typeUrl, MsgRelayPythPricesResponse);
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+export const MsgUpdateParams = {
+    typeUrl: "/injective.oracle.v1beta1.MsgUpdateParams",
+    aminoType: "oracle/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: "oracle/MsgUpdateParams",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.oracle.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.oracle.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.oracle.v1beta1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);