@burnt-labs/xion-types 0.0.1-test.1762962136

package/types/cosmos/nft/v1beta1/tx.amino.ts

@@ -0,0 +1,9 @@
+//@ts-nocheck
+import { MsgSend } from "./tx";
+export const AminoConverter = {
+  "/cosmos.nft.v1beta1.MsgSend": {
+    aminoType: "cosmos-sdk/MsgNFTSend",
+    toAmino: MsgSend.toAmino,
+    fromAmino: MsgSend.fromAmino
+  }
+};

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

@@ -0,0 +1,35 @@
+//@ts-nocheck
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgSend } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.nft.v1beta1.MsgSend", MsgSend]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+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/types/cosmos/nft/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,21 @@
+//@ts-nocheck
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgSend, MsgSendResponse } from "./tx";
+/** Msg defines the nft Msg service. */
+export interface Msg {
+  /** Send defines a method to send a nft from one account to another account. */
+  send(request: MsgSend): Promise<MsgSendResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.send = this.send.bind(this);
+  }
+  send(request: MsgSend): Promise<MsgSendResponse> {
+    const data = MsgSend.encode(request).finish();
+    const promise = this.rpc.request("cosmos.nft.v1beta1.Msg", "Send", data);
+    return promise.then(data => MsgSendResponse.decode(new BinaryReader(data)));
+  }
+}

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

@@ -0,0 +1,232 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** 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.
+ * @name MsgSendAmino
+ * @package cosmos.nft.v1beta1
+ * @see proto type: cosmos.nft.v1beta1.MsgSend
+ */
+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;
+}
+/** MsgSend represents a message to send a nft from one account to another account. */
+export interface MsgSendSDKType {
+  class_id: string;
+  id: string;
+  sender: string;
+  receiver: string;
+}
+/** 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.
+ * @name MsgSendResponseAmino
+ * @package cosmos.nft.v1beta1
+ * @see proto type: cosmos.nft.v1beta1.MsgSendResponse
+ */
+export interface MsgSendResponseAmino {}
+export interface MsgSendResponseAminoMsg {
+  type: "cosmos-sdk/MsgSendResponse";
+  value: MsgSendResponseAmino;
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponseSDKType {}
+function createBaseMsgSend(): MsgSend {
+  return {
+    classId: "",
+    id: "",
+    sender: "",
+    receiver: ""
+  };
+}
+export const MsgSend = {
+  typeUrl: "/cosmos.nft.v1beta1.MsgSend",
+  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: Partial<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()
+    };
+  }
+};
+function createBaseMsgSendResponse(): MsgSendResponse {
+  return {};
+}
+export const MsgSendResponse = {
+  typeUrl: "/cosmos.nft.v1beta1.MsgSendResponse",
+  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(_: Partial<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()
+    };
+  }
+};

package/types/cosmos/params/module/v1/module.ts

@@ -0,0 +1,77 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** Module is the config object of the params module. */
+export interface Module {}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.params.module.v1.Module";
+  value: Uint8Array;
+}
+/**
+ * Module is the config object of the params module.
+ * @name ModuleAmino
+ * @package cosmos.params.module.v1
+ * @see proto type: cosmos.params.module.v1.Module
+ */
+export interface ModuleAmino {}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+/** Module is the config object of the params module. */
+export interface ModuleSDKType {}
+function createBaseModule(): Module {
+  return {};
+}
+export const Module = {
+  typeUrl: "/cosmos.params.module.v1.Module",
+  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(_: Partial<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.params.module.v1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/params/v1beta1/params.ts

@@ -0,0 +1,262 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposal {
+  $typeUrl?: "/cosmos.params.v1beta1.ParameterChangeProposal";
+  title: string;
+  description: string;
+  changes: ParamChange[];
+}
+export interface ParameterChangeProposalProtoMsg {
+  typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal";
+  value: Uint8Array;
+}
+/**
+ * ParameterChangeProposal defines a proposal to change one or more parameters.
+ * @name ParameterChangeProposalAmino
+ * @package cosmos.params.v1beta1
+ * @see proto type: cosmos.params.v1beta1.ParameterChangeProposal
+ */
+export interface ParameterChangeProposalAmino {
+  title?: string;
+  description?: string;
+  changes: ParamChangeAmino[];
+}
+export interface ParameterChangeProposalAminoMsg {
+  type: "cosmos-sdk/ParameterChangeProposal";
+  value: ParameterChangeProposalAmino;
+}
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposalSDKType {
+  $typeUrl?: "/cosmos.params.v1beta1.ParameterChangeProposal";
+  title: string;
+  description: string;
+  changes: ParamChangeSDKType[];
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+export interface ParamChange {
+  subspace: string;
+  key: string;
+  value: string;
+}
+export interface ParamChangeProtoMsg {
+  typeUrl: "/cosmos.params.v1beta1.ParamChange";
+  value: Uint8Array;
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ * @name ParamChangeAmino
+ * @package cosmos.params.v1beta1
+ * @see proto type: cosmos.params.v1beta1.ParamChange
+ */
+export interface ParamChangeAmino {
+  subspace?: string;
+  key?: string;
+  value?: string;
+}
+export interface ParamChangeAminoMsg {
+  type: "cosmos-sdk/ParamChange";
+  value: ParamChangeAmino;
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+export interface ParamChangeSDKType {
+  subspace: string;
+  key: string;
+  value: string;
+}
+function createBaseParameterChangeProposal(): ParameterChangeProposal {
+  return {
+    $typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
+    title: "",
+    description: "",
+    changes: []
+  };
+}
+export const ParameterChangeProposal = {
+  typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
+  encode(message: ParameterChangeProposal, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.title !== "") {
+      writer.uint32(10).string(message.title);
+    }
+    if (message.description !== "") {
+      writer.uint32(18).string(message.description);
+    }
+    for (const v of message.changes) {
+      ParamChange.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ParameterChangeProposal {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParameterChangeProposal();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.title = reader.string();
+          break;
+        case 2:
+          message.description = reader.string();
+          break;
+        case 3:
+          message.changes.push(ParamChange.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ParameterChangeProposal>): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    message.title = object.title ?? "";
+    message.description = object.description ?? "";
+    message.changes = object.changes?.map(e => ParamChange.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: ParameterChangeProposalAmino): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    if (object.title !== undefined && object.title !== null) {
+      message.title = object.title;
+    }
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    message.changes = object.changes?.map(e => ParamChange.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: ParameterChangeProposal): ParameterChangeProposalAmino {
+    const obj: any = {};
+    obj.title = message.title === "" ? undefined : message.title;
+    obj.description = message.description === "" ? undefined : message.description;
+    if (message.changes) {
+      obj.changes = message.changes.map(e => e ? ParamChange.toAmino(e) : undefined);
+    } else {
+      obj.changes = message.changes;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ParameterChangeProposalAminoMsg): ParameterChangeProposal {
+    return ParameterChangeProposal.fromAmino(object.value);
+  },
+  toAminoMsg(message: ParameterChangeProposal): ParameterChangeProposalAminoMsg {
+    return {
+      type: "cosmos-sdk/ParameterChangeProposal",
+      value: ParameterChangeProposal.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParameterChangeProposalProtoMsg): ParameterChangeProposal {
+    return ParameterChangeProposal.decode(message.value);
+  },
+  toProto(message: ParameterChangeProposal): Uint8Array {
+    return ParameterChangeProposal.encode(message).finish();
+  },
+  toProtoMsg(message: ParameterChangeProposal): ParameterChangeProposalProtoMsg {
+    return {
+      typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
+      value: ParameterChangeProposal.encode(message).finish()
+    };
+  }
+};
+function createBaseParamChange(): ParamChange {
+  return {
+    subspace: "",
+    key: "",
+    value: ""
+  };
+}
+export const ParamChange = {
+  typeUrl: "/cosmos.params.v1beta1.ParamChange",
+  encode(message: ParamChange, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.subspace !== "") {
+      writer.uint32(10).string(message.subspace);
+    }
+    if (message.key !== "") {
+      writer.uint32(18).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(26).string(message.value);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ParamChange {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParamChange();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.subspace = reader.string();
+          break;
+        case 2:
+          message.key = reader.string();
+          break;
+        case 3:
+          message.value = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ParamChange>): ParamChange {
+    const message = createBaseParamChange();
+    message.subspace = object.subspace ?? "";
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+  fromAmino(object: ParamChangeAmino): ParamChange {
+    const message = createBaseParamChange();
+    if (object.subspace !== undefined && object.subspace !== null) {
+      message.subspace = object.subspace;
+    }
+    if (object.key !== undefined && object.key !== null) {
+      message.key = object.key;
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = object.value;
+    }
+    return message;
+  },
+  toAmino(message: ParamChange): ParamChangeAmino {
+    const obj: any = {};
+    obj.subspace = message.subspace === "" ? undefined : message.subspace;
+    obj.key = message.key === "" ? undefined : message.key;
+    obj.value = message.value === "" ? undefined : message.value;
+    return obj;
+  },
+  fromAminoMsg(object: ParamChangeAminoMsg): ParamChange {
+    return ParamChange.fromAmino(object.value);
+  },
+  toAminoMsg(message: ParamChange): ParamChangeAminoMsg {
+    return {
+      type: "cosmos-sdk/ParamChange",
+      value: ParamChange.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamChangeProtoMsg): ParamChange {
+    return ParamChange.decode(message.value);
+  },
+  toProto(message: ParamChange): Uint8Array {
+    return ParamChange.encode(message).finish();
+  },
+  toProtoMsg(message: ParamChange): ParamChangeProtoMsg {
+    return {
+      typeUrl: "/cosmos.params.v1beta1.ParamChange",
+      value: ParamChange.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/params/v1beta1/query.lcd.ts

@@ -0,0 +1,35 @@
+//@ts-nocheck
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QuerySubspacesRequest, QuerySubspacesResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+    this.subspaces = this.subspaces.bind(this);
+  }
+  /* Params queries a specific parameter of a module, given its subspace and
+   key. */
+  async params(params: QueryParamsRequest): Promise<QueryParamsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.subspace !== "undefined") {
+      options.params.subspace = params.subspace;
+    }
+    if (typeof params?.key !== "undefined") {
+      options.params.key = params.key;
+    }
+    const endpoint = `cosmos/params/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint, options);
+  }
+  /* Subspaces queries for all registered subspaces and all keys for a subspace. */
+  async subspaces(_params: QuerySubspacesRequest = {}): Promise<QuerySubspacesResponseSDKType> {
+    const endpoint = `cosmos/params/v1beta1/subspaces`;
+    return await this.req.get<QuerySubspacesResponseSDKType>(endpoint);
+  }
+}