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

package/types/cosmos/authz/v1beta1/event.ts

@@ -0,0 +1,274 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** EventGrant is emitted on Msg/Grant */
+export interface EventGrant {
+  /** Msg type URL for which an autorization is granted */
+  msgTypeUrl: string;
+  /** Granter account address */
+  granter: string;
+  /** Grantee account address */
+  grantee: string;
+}
+export interface EventGrantProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.EventGrant";
+  value: Uint8Array;
+}
+/**
+ * EventGrant is emitted on Msg/Grant
+ * @name EventGrantAmino
+ * @package cosmos.authz.v1beta1
+ * @see proto type: cosmos.authz.v1beta1.EventGrant
+ */
+export interface EventGrantAmino {
+  /**
+   * Msg type URL for which an autorization is granted
+   */
+  msg_type_url?: string;
+  /**
+   * Granter account address
+   */
+  granter?: string;
+  /**
+   * Grantee account address
+   */
+  grantee?: string;
+}
+export interface EventGrantAminoMsg {
+  type: "cosmos-sdk/EventGrant";
+  value: EventGrantAmino;
+}
+/** EventGrant is emitted on Msg/Grant */
+export interface EventGrantSDKType {
+  msg_type_url: string;
+  granter: string;
+  grantee: string;
+}
+/** EventRevoke is emitted on Msg/Revoke */
+export interface EventRevoke {
+  /** Msg type URL for which an autorization is revoked */
+  msgTypeUrl: string;
+  /** Granter account address */
+  granter: string;
+  /** Grantee account address */
+  grantee: string;
+}
+export interface EventRevokeProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.EventRevoke";
+  value: Uint8Array;
+}
+/**
+ * EventRevoke is emitted on Msg/Revoke
+ * @name EventRevokeAmino
+ * @package cosmos.authz.v1beta1
+ * @see proto type: cosmos.authz.v1beta1.EventRevoke
+ */
+export interface EventRevokeAmino {
+  /**
+   * Msg type URL for which an autorization is revoked
+   */
+  msg_type_url?: string;
+  /**
+   * Granter account address
+   */
+  granter?: string;
+  /**
+   * Grantee account address
+   */
+  grantee?: string;
+}
+export interface EventRevokeAminoMsg {
+  type: "cosmos-sdk/EventRevoke";
+  value: EventRevokeAmino;
+}
+/** EventRevoke is emitted on Msg/Revoke */
+export interface EventRevokeSDKType {
+  msg_type_url: string;
+  granter: string;
+  grantee: string;
+}
+function createBaseEventGrant(): EventGrant {
+  return {
+    msgTypeUrl: "",
+    granter: "",
+    grantee: ""
+  };
+}
+export const EventGrant = {
+  typeUrl: "/cosmos.authz.v1beta1.EventGrant",
+  encode(message: EventGrant, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.msgTypeUrl !== "") {
+      writer.uint32(18).string(message.msgTypeUrl);
+    }
+    if (message.granter !== "") {
+      writer.uint32(26).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(34).string(message.grantee);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): EventGrant {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventGrant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          message.msgTypeUrl = reader.string();
+          break;
+        case 3:
+          message.granter = reader.string();
+          break;
+        case 4:
+          message.grantee = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<EventGrant>): EventGrant {
+    const message = createBaseEventGrant();
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    return message;
+  },
+  fromAmino(object: EventGrantAmino): EventGrant {
+    const message = createBaseEventGrant();
+    if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
+      message.msgTypeUrl = object.msg_type_url;
+    }
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    return message;
+  },
+  toAmino(message: EventGrant): EventGrantAmino {
+    const obj: any = {};
+    obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    return obj;
+  },
+  fromAminoMsg(object: EventGrantAminoMsg): EventGrant {
+    return EventGrant.fromAmino(object.value);
+  },
+  toAminoMsg(message: EventGrant): EventGrantAminoMsg {
+    return {
+      type: "cosmos-sdk/EventGrant",
+      value: EventGrant.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: EventGrantProtoMsg): EventGrant {
+    return EventGrant.decode(message.value);
+  },
+  toProto(message: EventGrant): Uint8Array {
+    return EventGrant.encode(message).finish();
+  },
+  toProtoMsg(message: EventGrant): EventGrantProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.EventGrant",
+      value: EventGrant.encode(message).finish()
+    };
+  }
+};
+function createBaseEventRevoke(): EventRevoke {
+  return {
+    msgTypeUrl: "",
+    granter: "",
+    grantee: ""
+  };
+}
+export const EventRevoke = {
+  typeUrl: "/cosmos.authz.v1beta1.EventRevoke",
+  encode(message: EventRevoke, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.msgTypeUrl !== "") {
+      writer.uint32(18).string(message.msgTypeUrl);
+    }
+    if (message.granter !== "") {
+      writer.uint32(26).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(34).string(message.grantee);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): EventRevoke {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventRevoke();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          message.msgTypeUrl = reader.string();
+          break;
+        case 3:
+          message.granter = reader.string();
+          break;
+        case 4:
+          message.grantee = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<EventRevoke>): EventRevoke {
+    const message = createBaseEventRevoke();
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    return message;
+  },
+  fromAmino(object: EventRevokeAmino): EventRevoke {
+    const message = createBaseEventRevoke();
+    if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
+      message.msgTypeUrl = object.msg_type_url;
+    }
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    return message;
+  },
+  toAmino(message: EventRevoke): EventRevokeAmino {
+    const obj: any = {};
+    obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    return obj;
+  },
+  fromAminoMsg(object: EventRevokeAminoMsg): EventRevoke {
+    return EventRevoke.fromAmino(object.value);
+  },
+  toAminoMsg(message: EventRevoke): EventRevokeAminoMsg {
+    return {
+      type: "cosmos-sdk/EventRevoke",
+      value: EventRevoke.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: EventRevokeProtoMsg): EventRevoke {
+    return EventRevoke.decode(message.value);
+  },
+  toProto(message: EventRevoke): Uint8Array {
+    return EventRevoke.encode(message).finish();
+  },
+  toProtoMsg(message: EventRevoke): EventRevokeProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.EventRevoke",
+      value: EventRevoke.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/authz/v1beta1/genesis.ts

@@ -0,0 +1,99 @@
+//@ts-nocheck
+import { GrantAuthorization, GrantAuthorizationAmino, GrantAuthorizationSDKType } from "./authz";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the authz module's genesis state. */
+export interface GenesisState {
+  authorization: GrantAuthorization[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/**
+ * GenesisState defines the authz module's genesis state.
+ * @name GenesisStateAmino
+ * @package cosmos.authz.v1beta1
+ * @see proto type: cosmos.authz.v1beta1.GenesisState
+ */
+export interface GenesisStateAmino {
+  authorization: GrantAuthorizationAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the authz module's genesis state. */
+export interface GenesisStateSDKType {
+  authorization: GrantAuthorizationSDKType[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    authorization: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.authz.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.authorization) {
+      GrantAuthorization.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authorization.push(GrantAuthorization.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.authorization = object.authorization?.map(e => GrantAuthorization.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.authorization = object.authorization?.map(e => GrantAuthorization.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.authorization) {
+      obj.authorization = message.authorization.map(e => e ? GrantAuthorization.toAmino(e) : undefined);
+    } else {
+      obj.authorization = message.authorization;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

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

@@ -0,0 +1,59 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryGrantsRequest, QueryGrantsResponseSDKType, QueryGranterGrantsRequest, QueryGranterGrantsResponseSDKType, QueryGranteeGrantsRequest, QueryGranteeGrantsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.grants = this.grants.bind(this);
+    this.granterGrants = this.granterGrants.bind(this);
+    this.granteeGrants = this.granteeGrants.bind(this);
+  }
+  /* Returns list of `Authorization`, granted to the grantee by the granter. */
+  async grants(params: QueryGrantsRequest): Promise<QueryGrantsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.granter !== "undefined") {
+      options.params.granter = params.granter;
+    }
+    if (typeof params?.grantee !== "undefined") {
+      options.params.grantee = params.grantee;
+    }
+    if (typeof params?.msgTypeUrl !== "undefined") {
+      options.params.msg_type_url = params.msgTypeUrl;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/authz/v1beta1/grants`;
+    return await this.req.get<QueryGrantsResponseSDKType>(endpoint, options);
+  }
+  /* GranterGrants returns list of `GrantAuthorization`, granted by granter. */
+  async granterGrants(params: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/authz/v1beta1/grants/granter/${params.granter}`;
+    return await this.req.get<QueryGranterGrantsResponseSDKType>(endpoint, options);
+  }
+  /* GranteeGrants returns a list of `GrantAuthorization` by grantee. */
+  async granteeGrants(params: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/authz/v1beta1/grants/grantee/${params.grantee}`;
+    return await this.req.get<QueryGranteeGrantsResponseSDKType>(endpoint, options);
+  }
+}

package/types/cosmos/authz/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,53 @@
+//@ts-nocheck
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryGrantsRequest, QueryGrantsResponse, QueryGranterGrantsRequest, QueryGranterGrantsResponse, QueryGranteeGrantsRequest, QueryGranteeGrantsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /** Returns list of `Authorization`, granted to the grantee by the granter. */
+  grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse>;
+  /** GranterGrants returns list of `GrantAuthorization`, granted by granter. */
+  granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse>;
+  /** GranteeGrants returns a list of `GrantAuthorization` by grantee. */
+  granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.grants = this.grants.bind(this);
+    this.granterGrants = this.granterGrants.bind(this);
+    this.granteeGrants = this.granteeGrants.bind(this);
+  }
+  grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse> {
+    const data = QueryGrantsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Query", "Grants", data);
+    return promise.then(data => QueryGrantsResponse.decode(new BinaryReader(data)));
+  }
+  granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse> {
+    const data = QueryGranterGrantsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Query", "GranterGrants", data);
+    return promise.then(data => QueryGranterGrantsResponse.decode(new BinaryReader(data)));
+  }
+  granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse> {
+    const data = QueryGranteeGrantsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Query", "GranteeGrants", data);
+    return promise.then(data => QueryGranteeGrantsResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse> {
+      return queryService.grants(request);
+    },
+    granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse> {
+      return queryService.granterGrants(request);
+    },
+    granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse> {
+      return queryService.granteeGrants(request);
+    }
+  };
+};