injectivejs 1.4.0 → 1.6.0

package/injective/wasmx/v1/query.d.ts

@@ -0,0 +1,202 @@
+import { Params, ParamsAmino, RegisteredContract, RegisteredContractAmino } from "./wasmx";
+import { GenesisState, GenesisStateAmino } from "./genesis";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * QueryWasmxParamsRequest is the request type for the Query/WasmxParams RPC
+ * method.
+ */
+export interface QueryWasmxParamsRequest {
+}
+export interface QueryWasmxParamsRequestProtoMsg {
+    typeUrl: "/injective.wasmx.v1.QueryWasmxParamsRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryWasmxParamsRequest is the request type for the Query/WasmxParams RPC
+ * method.
+ */
+export interface QueryWasmxParamsRequestAmino {
+}
+export interface QueryWasmxParamsRequestAminoMsg {
+    type: "/injective.wasmx.v1.QueryWasmxParamsRequest";
+    value: QueryWasmxParamsRequestAmino;
+}
+/**
+ * QueryWasmxParamsRequest is the response type for the Query/WasmxParams RPC
+ * method.
+ */
+export interface QueryWasmxParamsResponse {
+    params: Params;
+}
+export interface QueryWasmxParamsResponseProtoMsg {
+    typeUrl: "/injective.wasmx.v1.QueryWasmxParamsResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryWasmxParamsRequest is the response type for the Query/WasmxParams RPC
+ * method.
+ */
+export interface QueryWasmxParamsResponseAmino {
+    params: ParamsAmino;
+}
+export interface QueryWasmxParamsResponseAminoMsg {
+    type: "/injective.wasmx.v1.QueryWasmxParamsResponse";
+    value: QueryWasmxParamsResponseAmino;
+}
+/**
+ * QueryModuleStateRequest is the request type for the Query/WasmxModuleState
+ * RPC method.
+ */
+export interface QueryModuleStateRequest {
+}
+export interface QueryModuleStateRequestProtoMsg {
+    typeUrl: "/injective.wasmx.v1.QueryModuleStateRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryModuleStateRequest is the request type for the Query/WasmxModuleState
+ * RPC method.
+ */
+export interface QueryModuleStateRequestAmino {
+}
+export interface QueryModuleStateRequestAminoMsg {
+    type: "/injective.wasmx.v1.QueryModuleStateRequest";
+    value: QueryModuleStateRequestAmino;
+}
+/**
+ * QueryModuleStateResponse is the response type for the Query/WasmxModuleState
+ * RPC method.
+ */
+export interface QueryModuleStateResponse {
+    state?: GenesisState;
+}
+export interface QueryModuleStateResponseProtoMsg {
+    typeUrl: "/injective.wasmx.v1.QueryModuleStateResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryModuleStateResponse is the response type for the Query/WasmxModuleState
+ * RPC method.
+ */
+export interface QueryModuleStateResponseAmino {
+    state?: GenesisStateAmino;
+}
+export interface QueryModuleStateResponseAminoMsg {
+    type: "/injective.wasmx.v1.QueryModuleStateResponse";
+    value: QueryModuleStateResponseAmino;
+}
+/** Contract registration info */
+export interface QueryContractRegistrationInfoRequest {
+    contractAddress: string;
+}
+export interface QueryContractRegistrationInfoRequestProtoMsg {
+    typeUrl: "/injective.wasmx.v1.QueryContractRegistrationInfoRequest";
+    value: Uint8Array;
+}
+/** Contract registration info */
+export interface QueryContractRegistrationInfoRequestAmino {
+    contract_address: string;
+}
+export interface QueryContractRegistrationInfoRequestAminoMsg {
+    type: "/injective.wasmx.v1.QueryContractRegistrationInfoRequest";
+    value: QueryContractRegistrationInfoRequestAmino;
+}
+export interface QueryContractRegistrationInfoResponse {
+    contract?: RegisteredContract;
+}
+export interface QueryContractRegistrationInfoResponseProtoMsg {
+    typeUrl: "/injective.wasmx.v1.QueryContractRegistrationInfoResponse";
+    value: Uint8Array;
+}
+export interface QueryContractRegistrationInfoResponseAmino {
+    contract?: RegisteredContractAmino;
+}
+export interface QueryContractRegistrationInfoResponseAminoMsg {
+    type: "/injective.wasmx.v1.QueryContractRegistrationInfoResponse";
+    value: QueryContractRegistrationInfoResponseAmino;
+}
+export declare const QueryWasmxParamsRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryWasmxParamsRequest;
+    isAmino(o: any): o is QueryWasmxParamsRequestAmino;
+    encode(_: QueryWasmxParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryWasmxParamsRequest;
+    fromPartial(_: DeepPartial<QueryWasmxParamsRequest>): QueryWasmxParamsRequest;
+    fromAmino(_: QueryWasmxParamsRequestAmino): QueryWasmxParamsRequest;
+    toAmino(_: QueryWasmxParamsRequest): QueryWasmxParamsRequestAmino;
+    fromAminoMsg(object: QueryWasmxParamsRequestAminoMsg): QueryWasmxParamsRequest;
+    fromProtoMsg(message: QueryWasmxParamsRequestProtoMsg): QueryWasmxParamsRequest;
+    toProto(message: QueryWasmxParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryWasmxParamsRequest): QueryWasmxParamsRequestProtoMsg;
+};
+export declare const QueryWasmxParamsResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryWasmxParamsResponse;
+    isAmino(o: any): o is QueryWasmxParamsResponseAmino;
+    encode(message: QueryWasmxParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryWasmxParamsResponse;
+    fromPartial(object: DeepPartial<QueryWasmxParamsResponse>): QueryWasmxParamsResponse;
+    fromAmino(object: QueryWasmxParamsResponseAmino): QueryWasmxParamsResponse;
+    toAmino(message: QueryWasmxParamsResponse): QueryWasmxParamsResponseAmino;
+    fromAminoMsg(object: QueryWasmxParamsResponseAminoMsg): QueryWasmxParamsResponse;
+    fromProtoMsg(message: QueryWasmxParamsResponseProtoMsg): QueryWasmxParamsResponse;
+    toProto(message: QueryWasmxParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryWasmxParamsResponse): QueryWasmxParamsResponseProtoMsg;
+};
+export declare const QueryModuleStateRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryModuleStateRequest;
+    isAmino(o: any): o is QueryModuleStateRequestAmino;
+    encode(_: QueryModuleStateRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryModuleStateRequest;
+    fromPartial(_: DeepPartial<QueryModuleStateRequest>): QueryModuleStateRequest;
+    fromAmino(_: QueryModuleStateRequestAmino): QueryModuleStateRequest;
+    toAmino(_: QueryModuleStateRequest): QueryModuleStateRequestAmino;
+    fromAminoMsg(object: QueryModuleStateRequestAminoMsg): QueryModuleStateRequest;
+    fromProtoMsg(message: QueryModuleStateRequestProtoMsg): QueryModuleStateRequest;
+    toProto(message: QueryModuleStateRequest): Uint8Array;
+    toProtoMsg(message: QueryModuleStateRequest): QueryModuleStateRequestProtoMsg;
+};
+export declare const QueryModuleStateResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryModuleStateResponse;
+    isAmino(o: any): o is QueryModuleStateResponseAmino;
+    encode(message: QueryModuleStateResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryModuleStateResponse;
+    fromPartial(object: DeepPartial<QueryModuleStateResponse>): QueryModuleStateResponse;
+    fromAmino(object: QueryModuleStateResponseAmino): QueryModuleStateResponse;
+    toAmino(message: QueryModuleStateResponse): QueryModuleStateResponseAmino;
+    fromAminoMsg(object: QueryModuleStateResponseAminoMsg): QueryModuleStateResponse;
+    fromProtoMsg(message: QueryModuleStateResponseProtoMsg): QueryModuleStateResponse;
+    toProto(message: QueryModuleStateResponse): Uint8Array;
+    toProtoMsg(message: QueryModuleStateResponse): QueryModuleStateResponseProtoMsg;
+};
+export declare const QueryContractRegistrationInfoRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryContractRegistrationInfoRequest;
+    isAmino(o: any): o is QueryContractRegistrationInfoRequestAmino;
+    encode(message: QueryContractRegistrationInfoRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractRegistrationInfoRequest;
+    fromPartial(object: DeepPartial<QueryContractRegistrationInfoRequest>): QueryContractRegistrationInfoRequest;
+    fromAmino(object: QueryContractRegistrationInfoRequestAmino): QueryContractRegistrationInfoRequest;
+    toAmino(message: QueryContractRegistrationInfoRequest): QueryContractRegistrationInfoRequestAmino;
+    fromAminoMsg(object: QueryContractRegistrationInfoRequestAminoMsg): QueryContractRegistrationInfoRequest;
+    fromProtoMsg(message: QueryContractRegistrationInfoRequestProtoMsg): QueryContractRegistrationInfoRequest;
+    toProto(message: QueryContractRegistrationInfoRequest): Uint8Array;
+    toProtoMsg(message: QueryContractRegistrationInfoRequest): QueryContractRegistrationInfoRequestProtoMsg;
+};
+export declare const QueryContractRegistrationInfoResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryContractRegistrationInfoResponse;
+    isAmino(o: any): o is QueryContractRegistrationInfoResponseAmino;
+    encode(message: QueryContractRegistrationInfoResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryContractRegistrationInfoResponse;
+    fromPartial(object: DeepPartial<QueryContractRegistrationInfoResponse>): QueryContractRegistrationInfoResponse;
+    fromAmino(object: QueryContractRegistrationInfoResponseAmino): QueryContractRegistrationInfoResponse;
+    toAmino(message: QueryContractRegistrationInfoResponse): QueryContractRegistrationInfoResponseAmino;
+    fromAminoMsg(object: QueryContractRegistrationInfoResponseAminoMsg): QueryContractRegistrationInfoResponse;
+    fromProtoMsg(message: QueryContractRegistrationInfoResponseProtoMsg): QueryContractRegistrationInfoResponse;
+    toProto(message: QueryContractRegistrationInfoResponse): Uint8Array;
+    toProtoMsg(message: QueryContractRegistrationInfoResponse): QueryContractRegistrationInfoResponseProtoMsg;
+};

package/injective/wasmx/v1/query.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryContractRegistrationInfoResponse = exports.QueryContractRegistrationInfoRequest = exports.QueryModuleStateResponse = exports.QueryModuleStateRequest = exports.QueryWasmxParamsResponse = exports.QueryWasmxParamsRequest = void 0;
+const wasmx_1 = require("./wasmx");
+const genesis_1 = require("./genesis");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseQueryWasmxParamsRequest() {
+    return {};
+}
+exports.QueryWasmxParamsRequest = {
+    typeUrl: "/injective.wasmx.v1.QueryWasmxParamsRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryWasmxParamsRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryWasmxParamsRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryWasmxParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryWasmxParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryWasmxParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryWasmxParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryWasmxParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryWasmxParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.QueryWasmxParamsRequest",
+            value: exports.QueryWasmxParamsRequest.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryWasmxParamsRequest.typeUrl, exports.QueryWasmxParamsRequest);
+function createBaseQueryWasmxParamsResponse() {
+    return {
+        params: wasmx_1.Params.fromPartial({})
+    };
+}
+exports.QueryWasmxParamsResponse = {
+    typeUrl: "/injective.wasmx.v1.QueryWasmxParamsResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryWasmxParamsResponse.typeUrl || wasmx_1.Params.is(o.params));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryWasmxParamsResponse.typeUrl || wasmx_1.Params.isAmino(o.params));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            wasmx_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryWasmxParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = wasmx_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryWasmxParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? wasmx_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryWasmxParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = wasmx_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? wasmx_1.Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryWasmxParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryWasmxParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryWasmxParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.QueryWasmxParamsResponse",
+            value: exports.QueryWasmxParamsResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryWasmxParamsResponse.typeUrl, exports.QueryWasmxParamsResponse);
+function createBaseQueryModuleStateRequest() {
+    return {};
+}
+exports.QueryModuleStateRequest = {
+    typeUrl: "/injective.wasmx.v1.QueryModuleStateRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryModuleStateRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryModuleStateRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryModuleStateRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryModuleStateRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryModuleStateRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryModuleStateRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryModuleStateRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryModuleStateRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.QueryModuleStateRequest",
+            value: exports.QueryModuleStateRequest.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryModuleStateRequest.typeUrl, exports.QueryModuleStateRequest);
+function createBaseQueryModuleStateResponse() {
+    return {
+        state: undefined
+    };
+}
+exports.QueryModuleStateResponse = {
+    typeUrl: "/injective.wasmx.v1.QueryModuleStateResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryModuleStateResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryModuleStateResponse.typeUrl;
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.state !== undefined) {
+            genesis_1.GenesisState.encode(message.state, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryModuleStateResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.state = genesis_1.GenesisState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryModuleStateResponse();
+        message.state = object.state !== undefined && object.state !== null ? genesis_1.GenesisState.fromPartial(object.state) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryModuleStateResponse();
+        if (object.state !== undefined && object.state !== null) {
+            message.state = genesis_1.GenesisState.fromAmino(object.state);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.state = message.state ? genesis_1.GenesisState.toAmino(message.state) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryModuleStateResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryModuleStateResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryModuleStateResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.QueryModuleStateResponse",
+            value: exports.QueryModuleStateResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryModuleStateResponse.typeUrl, exports.QueryModuleStateResponse);
+function createBaseQueryContractRegistrationInfoRequest() {
+    return {
+        contractAddress: ""
+    };
+}
+exports.QueryContractRegistrationInfoRequest = {
+    typeUrl: "/injective.wasmx.v1.QueryContractRegistrationInfoRequest",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryContractRegistrationInfoRequest.typeUrl || typeof o.contractAddress === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryContractRegistrationInfoRequest.typeUrl || typeof o.contract_address === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.contractAddress !== "") {
+            writer.uint32(10).string(message.contractAddress);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryContractRegistrationInfoRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contractAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryContractRegistrationInfoRequest();
+        message.contractAddress = object.contractAddress ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryContractRegistrationInfoRequest();
+        if (object.contract_address !== undefined && object.contract_address !== null) {
+            message.contractAddress = object.contract_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.contract_address = message.contractAddress === "" ? undefined : message.contractAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryContractRegistrationInfoRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryContractRegistrationInfoRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryContractRegistrationInfoRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.QueryContractRegistrationInfoRequest",
+            value: exports.QueryContractRegistrationInfoRequest.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryContractRegistrationInfoRequest.typeUrl, exports.QueryContractRegistrationInfoRequest);
+function createBaseQueryContractRegistrationInfoResponse() {
+    return {
+        contract: undefined
+    };
+}
+exports.QueryContractRegistrationInfoResponse = {
+    typeUrl: "/injective.wasmx.v1.QueryContractRegistrationInfoResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryContractRegistrationInfoResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryContractRegistrationInfoResponse.typeUrl;
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.contract !== undefined) {
+            wasmx_1.RegisteredContract.encode(message.contract, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryContractRegistrationInfoResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contract = wasmx_1.RegisteredContract.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryContractRegistrationInfoResponse();
+        message.contract = object.contract !== undefined && object.contract !== null ? wasmx_1.RegisteredContract.fromPartial(object.contract) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryContractRegistrationInfoResponse();
+        if (object.contract !== undefined && object.contract !== null) {
+            message.contract = wasmx_1.RegisteredContract.fromAmino(object.contract);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.contract = message.contract ? wasmx_1.RegisteredContract.toAmino(message.contract) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryContractRegistrationInfoResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryContractRegistrationInfoResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryContractRegistrationInfoResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.wasmx.v1.QueryContractRegistrationInfoResponse",
+            value: exports.QueryContractRegistrationInfoResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryContractRegistrationInfoResponse.typeUrl, exports.QueryContractRegistrationInfoResponse);

package/injective/wasmx/v1/query.rpc.func.d.ts

@@ -0,0 +1,5 @@
+import { RpcResolver } from "../../../helper-func-types";
+import { QueryWasmxParamsRequest, QueryWasmxParamsResponse, QueryContractRegistrationInfoRequest, QueryContractRegistrationInfoResponse, QueryModuleStateRequest, QueryModuleStateResponse } from "./query";
+export declare const createGetWasmxParams: (clientResolver?: RpcResolver) => (request: QueryWasmxParamsRequest) => Promise<QueryWasmxParamsResponse>;
+export declare const createGetContractRegistrationInfo: (clientResolver?: RpcResolver) => (request: QueryContractRegistrationInfoRequest) => Promise<QueryContractRegistrationInfoResponse>;
+export declare const createGetWasmxModuleState: (clientResolver?: RpcResolver) => (request: QueryModuleStateRequest) => Promise<QueryModuleStateResponse>;

package/injective/wasmx/v1/query.rpc.func.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetWasmxModuleState = exports.createGetContractRegistrationInfo = exports.createGetWasmxParams = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const query_1 = require("./query");
+const createGetWasmxParams = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryWasmxParamsRequest.encode,
+    decode: query_1.QueryWasmxParamsResponse.decode,
+    service: "injective.wasmx.v1.Query",
+    method: "WasmxParams",
+    clientResolver
+});
+exports.createGetWasmxParams = createGetWasmxParams;
+const createGetContractRegistrationInfo = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryContractRegistrationInfoRequest.encode,
+    decode: query_1.QueryContractRegistrationInfoResponse.decode,
+    service: "injective.wasmx.v1.Query",
+    method: "ContractRegistrationInfo",
+    clientResolver
+});
+exports.createGetContractRegistrationInfo = createGetContractRegistrationInfo;
+const createGetWasmxModuleState = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryModuleStateRequest.encode,
+    decode: query_1.QueryModuleStateResponse.decode,
+    service: "injective.wasmx.v1.Query",
+    method: "WasmxModuleState",
+    clientResolver
+});
+exports.createGetWasmxModuleState = createGetWasmxModuleState;