@xpla/xpla-react 1.7.0-beta.0

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

@@ -0,0 +1,259 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** 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 */
+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;
+}
+/** 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 */
+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;
+}
+function createBaseEventGrant(): EventGrant {
+  return {
+    msgTypeUrl: "",
+    granter: "",
+    grantee: ""
+  };
+}
+export const EventGrant = {
+  typeUrl: "/cosmos.authz.v1beta1.EventGrant",
+  aminoType: "cosmos-sdk/EventGrant",
+  is(o: any): o is EventGrant {
+    return o && (o.$typeUrl === EventGrant.typeUrl || typeof o.msgTypeUrl === "string" && typeof o.granter === "string" && typeof o.grantee === "string");
+  },
+  isAmino(o: any): o is EventGrantAmino {
+    return o && (o.$typeUrl === EventGrant.typeUrl || typeof o.msg_type_url === "string" && typeof o.granter === "string" && typeof o.grantee === "string");
+  },
+  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: DeepPartial<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()
+    };
+  }
+};
+GlobalDecoderRegistry.register(EventGrant.typeUrl, EventGrant);
+GlobalDecoderRegistry.registerAminoProtoMapping(EventGrant.aminoType, EventGrant.typeUrl);
+function createBaseEventRevoke(): EventRevoke {
+  return {
+    msgTypeUrl: "",
+    granter: "",
+    grantee: ""
+  };
+}
+export const EventRevoke = {
+  typeUrl: "/cosmos.authz.v1beta1.EventRevoke",
+  aminoType: "cosmos-sdk/EventRevoke",
+  is(o: any): o is EventRevoke {
+    return o && (o.$typeUrl === EventRevoke.typeUrl || typeof o.msgTypeUrl === "string" && typeof o.granter === "string" && typeof o.grantee === "string");
+  },
+  isAmino(o: any): o is EventRevokeAmino {
+    return o && (o.$typeUrl === EventRevoke.typeUrl || typeof o.msg_type_url === "string" && typeof o.granter === "string" && typeof o.grantee === "string");
+  },
+  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: DeepPartial<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()
+    };
+  }
+};
+GlobalDecoderRegistry.register(EventRevoke.typeUrl, EventRevoke);
+GlobalDecoderRegistry.registerAminoProtoMapping(EventRevoke.aminoType, EventRevoke.typeUrl);

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

@@ -0,0 +1,100 @@
+import { GrantAuthorization, GrantAuthorizationAmino } from "./authz";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** 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. */
+export interface GenesisStateAmino {
+  authorization: GrantAuthorizationAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    authorization: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.authz.v1beta1.GenesisState",
+  aminoType: "cosmos-sdk/GenesisState",
+  is(o: any): o is GenesisState {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.authorization) && (!o.authorization.length || GrantAuthorization.is(o.authorization[0])));
+  },
+  isAmino(o: any): o is GenesisStateAmino {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Array.isArray(o.authorization) && (!o.authorization.length || GrantAuthorization.isAmino(o.authorization[0])));
+  },
+  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: DeepPartial<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()
+    };
+  }
+};
+GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);
+GlobalDecoderRegistry.registerAminoProtoMapping(GenesisState.aminoType, GenesisState.typeUrl);

package/src/cosmos/authz/v1beta1/query.rpc.func.ts

@@ -0,0 +1,36 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { buildUseQuery } from "../../../react-query";
+import { QueryGrantsRequest, QueryGrantsResponse, QueryGranterGrantsRequest, QueryGranterGrantsResponse, QueryGranteeGrantsRequest, QueryGranteeGrantsResponse } from "./query";
+export const createGetGrants = (clientResolver?: RpcResolver) => buildQuery<QueryGrantsRequest, QueryGrantsResponse>({
+  encode: QueryGrantsRequest.encode,
+  decode: QueryGrantsResponse.decode,
+  service: "cosmos.authz.v1beta1.Query",
+  method: "Grants",
+  clientResolver
+});
+export const useGetGrants = buildUseQuery<QueryGrantsRequest, QueryGrantsResponse>({
+  builderQueryFn: createGetGrants,
+  queryKeyPrefix: "GrantsQuery"
+});
+export const createGetGranterGrants = (clientResolver?: RpcResolver) => buildQuery<QueryGranterGrantsRequest, QueryGranterGrantsResponse>({
+  encode: QueryGranterGrantsRequest.encode,
+  decode: QueryGranterGrantsResponse.decode,
+  service: "cosmos.authz.v1beta1.Query",
+  method: "GranterGrants",
+  clientResolver
+});
+export const useGetGranterGrants = buildUseQuery<QueryGranterGrantsRequest, QueryGranterGrantsResponse>({
+  builderQueryFn: createGetGranterGrants,
+  queryKeyPrefix: "GranterGrantsQuery"
+});
+export const createGetGranteeGrants = (clientResolver?: RpcResolver) => buildQuery<QueryGranteeGrantsRequest, QueryGranteeGrantsResponse>({
+  encode: QueryGranteeGrantsRequest.encode,
+  decode: QueryGranteeGrantsResponse.decode,
+  service: "cosmos.authz.v1beta1.Query",
+  method: "GranteeGrants",
+  clientResolver
+});
+export const useGetGranteeGrants = buildUseQuery<QueryGranteeGrantsRequest, QueryGranteeGrantsResponse>({
+  builderQueryFn: createGetGranteeGrants,
+  queryKeyPrefix: "GranteeGrantsQuery"
+});