@xpla/xpla-react 1.7.0-beta.0

package/src/cosmos/nft/v1beta1/tx.registry.ts

@@ -0,0 +1,29 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { MsgSend } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.nft.v1beta1.MsgSend", MsgSend]];
+export const MessageComposer = {
+  encoded: {
+    send(value: MsgSend) {
+      return {
+        typeUrl: "/cosmos.nft.v1beta1.MsgSend",
+        value: MsgSend.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    send(value: MsgSend) {
+      return {
+        typeUrl: "/cosmos.nft.v1beta1.MsgSend",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    send(value: MsgSend) {
+      return {
+        typeUrl: "/cosmos.nft.v1beta1.MsgSend",
+        value: MsgSend.fromPartial(value)
+      };
+    }
+  }
+};

package/src/cosmos/nft/v1beta1/tx.rpc.func.ts

@@ -0,0 +1,13 @@
+import { buildTx, SigningClientResolver } from "../../../helper-func-types";
+import { buildUseMutation } from "../../../react-query";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgSend } from "./tx";
+export const createSend = (clientResolver?: SigningClientResolver) => buildTx<MsgSend>({
+  clientResolver,
+  typeUrl: MsgSend.typeUrl,
+  encoders: toEncoders(MsgSend),
+  converters: toConverters(MsgSend)
+});
+export const useSend = buildUseMutation<MsgSend, Error>({
+  builderMutationFn: createSend
+});

package/src/cosmos/nft/v1beta1/tx.ts

@@ -0,0 +1,224 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** MsgSend represents a message to send a nft from one account to another account. */
+export interface MsgSend {
+  /** class_id defines the unique identifier of the nft classification, similar to the contract address of ERC721 */
+  classId: string;
+  /** id defines the unique identification of nft */
+  id: string;
+  /** sender is the address of the owner of nft */
+  sender: string;
+  /** receiver is the receiver address of nft */
+  receiver: string;
+}
+export interface MsgSendProtoMsg {
+  typeUrl: "/cosmos.nft.v1beta1.MsgSend";
+  value: Uint8Array;
+}
+/** MsgSend represents a message to send a nft from one account to another account. */
+export interface MsgSendAmino {
+  /** class_id defines the unique identifier of the nft classification, similar to the contract address of ERC721 */
+  class_id: string;
+  /** id defines the unique identification of nft */
+  id: string;
+  /** sender is the address of the owner of nft */
+  sender: string;
+  /** receiver is the receiver address of nft */
+  receiver: string;
+}
+export interface MsgSendAminoMsg {
+  type: "cosmos-sdk/MsgNFTSend";
+  value: MsgSendAmino;
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponse {}
+export interface MsgSendResponseProtoMsg {
+  typeUrl: "/cosmos.nft.v1beta1.MsgSendResponse";
+  value: Uint8Array;
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponseAmino {}
+export interface MsgSendResponseAminoMsg {
+  type: "cosmos-sdk/MsgSendResponse";
+  value: MsgSendResponseAmino;
+}
+function createBaseMsgSend(): MsgSend {
+  return {
+    classId: "",
+    id: "",
+    sender: "",
+    receiver: ""
+  };
+}
+export const MsgSend = {
+  typeUrl: "/cosmos.nft.v1beta1.MsgSend",
+  aminoType: "cosmos-sdk/MsgNFTSend",
+  is(o: any): o is MsgSend {
+    return o && (o.$typeUrl === MsgSend.typeUrl || typeof o.classId === "string" && typeof o.id === "string" && typeof o.sender === "string" && typeof o.receiver === "string");
+  },
+  isAmino(o: any): o is MsgSendAmino {
+    return o && (o.$typeUrl === MsgSend.typeUrl || typeof o.class_id === "string" && typeof o.id === "string" && typeof o.sender === "string" && typeof o.receiver === "string");
+  },
+  encode(message: MsgSend, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.classId !== "") {
+      writer.uint32(10).string(message.classId);
+    }
+    if (message.id !== "") {
+      writer.uint32(18).string(message.id);
+    }
+    if (message.sender !== "") {
+      writer.uint32(26).string(message.sender);
+    }
+    if (message.receiver !== "") {
+      writer.uint32(34).string(message.receiver);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSend {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSend();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.classId = reader.string();
+          break;
+        case 2:
+          message.id = reader.string();
+          break;
+        case 3:
+          message.sender = reader.string();
+          break;
+        case 4:
+          message.receiver = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<MsgSend>): MsgSend {
+    const message = createBaseMsgSend();
+    message.classId = object.classId ?? "";
+    message.id = object.id ?? "";
+    message.sender = object.sender ?? "";
+    message.receiver = object.receiver ?? "";
+    return message;
+  },
+  fromAmino(object: MsgSendAmino): MsgSend {
+    const message = createBaseMsgSend();
+    if (object.class_id !== undefined && object.class_id !== null) {
+      message.classId = object.class_id;
+    }
+    if (object.id !== undefined && object.id !== null) {
+      message.id = object.id;
+    }
+    if (object.sender !== undefined && object.sender !== null) {
+      message.sender = object.sender;
+    }
+    if (object.receiver !== undefined && object.receiver !== null) {
+      message.receiver = object.receiver;
+    }
+    return message;
+  },
+  toAmino(message: MsgSend): MsgSendAmino {
+    const obj: any = {};
+    obj.class_id = message.classId === "" ? undefined : message.classId;
+    obj.id = message.id === "" ? undefined : message.id;
+    obj.sender = message.sender === "" ? undefined : message.sender;
+    obj.receiver = message.receiver === "" ? undefined : message.receiver;
+    return obj;
+  },
+  fromAminoMsg(object: MsgSendAminoMsg): MsgSend {
+    return MsgSend.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSend): MsgSendAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgNFTSend",
+      value: MsgSend.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSendProtoMsg): MsgSend {
+    return MsgSend.decode(message.value);
+  },
+  toProto(message: MsgSend): Uint8Array {
+    return MsgSend.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSend): MsgSendProtoMsg {
+    return {
+      typeUrl: "/cosmos.nft.v1beta1.MsgSend",
+      value: MsgSend.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgSend.typeUrl, MsgSend);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgSend.aminoType, MsgSend.typeUrl);
+function createBaseMsgSendResponse(): MsgSendResponse {
+  return {};
+}
+export const MsgSendResponse = {
+  typeUrl: "/cosmos.nft.v1beta1.MsgSendResponse",
+  aminoType: "cosmos-sdk/MsgSendResponse",
+  is(o: any): o is MsgSendResponse {
+    return o && o.$typeUrl === MsgSendResponse.typeUrl;
+  },
+  isAmino(o: any): o is MsgSendResponseAmino {
+    return o && o.$typeUrl === MsgSendResponse.typeUrl;
+  },
+  encode(_: MsgSendResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSendResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<MsgSendResponse>): MsgSendResponse {
+    const message = createBaseMsgSendResponse();
+    return message;
+  },
+  fromAmino(_: MsgSendResponseAmino): MsgSendResponse {
+    const message = createBaseMsgSendResponse();
+    return message;
+  },
+  toAmino(_: MsgSendResponse): MsgSendResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgSendResponseAminoMsg): MsgSendResponse {
+    return MsgSendResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSendResponse): MsgSendResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSendResponse",
+      value: MsgSendResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSendResponseProtoMsg): MsgSendResponse {
+    return MsgSendResponse.decode(message.value);
+  },
+  toProto(message: MsgSendResponse): Uint8Array {
+    return MsgSendResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSendResponse): MsgSendResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.nft.v1beta1.MsgSendResponse",
+      value: MsgSendResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgSendResponse.typeUrl, MsgSendResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgSendResponse.aminoType, MsgSendResponse.typeUrl);

package/src/cosmos/orm/module/v1alpha1/module.ts

@@ -0,0 +1,88 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/**
+ * Module defines the ORM module which adds providers to the app container for
+ * ORM ModuleDB's and in the future will automatically register query
+ * services for modules that use the ORM.
+ */
+export interface Module {}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.orm.module.v1alpha1.Module";
+  value: Uint8Array;
+}
+/**
+ * Module defines the ORM module which adds providers to the app container for
+ * ORM ModuleDB's and in the future will automatically register query
+ * services for modules that use the ORM.
+ */
+export interface ModuleAmino {}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+function createBaseModule(): Module {
+  return {};
+}
+export const Module = {
+  typeUrl: "/cosmos.orm.module.v1alpha1.Module",
+  aminoType: "cosmos-sdk/Module",
+  is(o: any): o is Module {
+    return o && o.$typeUrl === Module.typeUrl;
+  },
+  isAmino(o: any): o is ModuleAmino {
+    return o && o.$typeUrl === Module.typeUrl;
+  },
+  encode(_: Module, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Module {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    return message;
+  },
+  fromAmino(_: ModuleAmino): Module {
+    const message = createBaseModule();
+    return message;
+  },
+  toAmino(_: Module): ModuleAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAminoMsg): Module {
+    return Module.fromAmino(object.value);
+  },
+  toAminoMsg(message: Module): ModuleAminoMsg {
+    return {
+      type: "cosmos-sdk/Module",
+      value: Module.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleProtoMsg): Module {
+    return Module.decode(message.value);
+  },
+  toProto(message: Module): Uint8Array {
+    return Module.encode(message).finish();
+  },
+  toProtoMsg(message: Module): ModuleProtoMsg {
+    return {
+      typeUrl: "/cosmos.orm.module.v1alpha1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Module.typeUrl, Module);
+GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

package/src/cosmos/orm/query/v1alpha1/query.rpc.func.ts

@@ -0,0 +1,25 @@
+import { RpcResolver, buildQuery } from "../../../../helper-func-types";
+import { buildUseQuery } from "../../../../react-query";
+import { GetRequest, GetResponse, ListRequest, ListResponse } from "./query";
+export const createGetGet = (clientResolver?: RpcResolver) => buildQuery<GetRequest, GetResponse>({
+  encode: GetRequest.encode,
+  decode: GetResponse.decode,
+  service: "cosmos.orm.query.v1alpha1.Query",
+  method: "Get",
+  clientResolver
+});
+export const useGetGet = buildUseQuery<GetRequest, GetResponse>({
+  builderQueryFn: createGetGet,
+  queryKeyPrefix: "GetQuery"
+});
+export const createGetList = (clientResolver?: RpcResolver) => buildQuery<ListRequest, ListResponse>({
+  encode: ListRequest.encode,
+  decode: ListResponse.decode,
+  service: "cosmos.orm.query.v1alpha1.Query",
+  method: "List",
+  clientResolver
+});
+export const useGetList = buildUseQuery<ListRequest, ListResponse>({
+  builderQueryFn: createGetList,
+  queryKeyPrefix: "ListQuery"
+});