@xpla/xpla-react 1.7.0-beta.0

package/src/cosmos/auth/module/v1/module.ts

@@ -0,0 +1,253 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** Module is the config object for the auth module. */
+export interface Module {
+  /** bech32_prefix is the bech32 account prefix for the app. */
+  bech32Prefix: string;
+  /** module_account_permissions are module account permissions. */
+  moduleAccountPermissions: ModuleAccountPermission[];
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.auth.module.v1.Module";
+  value: Uint8Array;
+}
+/** Module is the config object for the auth module. */
+export interface ModuleAmino {
+  /** bech32_prefix is the bech32 account prefix for the app. */
+  bech32_prefix: string;
+  /** module_account_permissions are module account permissions. */
+  module_account_permissions: ModuleAccountPermissionAmino[];
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+/** ModuleAccountPermission represents permissions for a module account. */
+export interface ModuleAccountPermission {
+  /** account is the name of the module. */
+  account: string;
+  /**
+   * permissions are the permissions this module has. Currently recognized
+   * values are minter, burner and staking.
+   */
+  permissions: string[];
+}
+export interface ModuleAccountPermissionProtoMsg {
+  typeUrl: "/cosmos.auth.module.v1.ModuleAccountPermission";
+  value: Uint8Array;
+}
+/** ModuleAccountPermission represents permissions for a module account. */
+export interface ModuleAccountPermissionAmino {
+  /** account is the name of the module. */
+  account: string;
+  /**
+   * permissions are the permissions this module has. Currently recognized
+   * values are minter, burner and staking.
+   */
+  permissions: string[];
+}
+export interface ModuleAccountPermissionAminoMsg {
+  type: "cosmos-sdk/ModuleAccountPermission";
+  value: ModuleAccountPermissionAmino;
+}
+function createBaseModule(): Module {
+  return {
+    bech32Prefix: "",
+    moduleAccountPermissions: [],
+    authority: ""
+  };
+}
+export const Module = {
+  typeUrl: "/cosmos.auth.module.v1.Module",
+  aminoType: "cosmos-sdk/Module",
+  is(o: any): o is Module {
+    return o && (o.$typeUrl === Module.typeUrl || typeof o.bech32Prefix === "string" && Array.isArray(o.moduleAccountPermissions) && (!o.moduleAccountPermissions.length || ModuleAccountPermission.is(o.moduleAccountPermissions[0])) && typeof o.authority === "string");
+  },
+  isAmino(o: any): o is ModuleAmino {
+    return o && (o.$typeUrl === Module.typeUrl || typeof o.bech32_prefix === "string" && Array.isArray(o.module_account_permissions) && (!o.module_account_permissions.length || ModuleAccountPermission.isAmino(o.module_account_permissions[0])) && typeof o.authority === "string");
+  },
+  encode(message: Module, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.bech32Prefix !== "") {
+      writer.uint32(10).string(message.bech32Prefix);
+    }
+    for (const v of message.moduleAccountPermissions) {
+      ModuleAccountPermission.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.authority !== "") {
+      writer.uint32(26).string(message.authority);
+    }
+    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) {
+        case 1:
+          message.bech32Prefix = reader.string();
+          break;
+        case 2:
+          message.moduleAccountPermissions.push(ModuleAccountPermission.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.authority = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.bech32Prefix = object.bech32Prefix ?? "";
+    message.moduleAccountPermissions = object.moduleAccountPermissions?.map(e => ModuleAccountPermission.fromPartial(e)) || [];
+    message.authority = object.authority ?? "";
+    return message;
+  },
+  fromAmino(object: ModuleAmino): Module {
+    const message = createBaseModule();
+    if (object.bech32_prefix !== undefined && object.bech32_prefix !== null) {
+      message.bech32Prefix = object.bech32_prefix;
+    }
+    message.moduleAccountPermissions = object.module_account_permissions?.map(e => ModuleAccountPermission.fromAmino(e)) || [];
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    return message;
+  },
+  toAmino(message: Module): ModuleAmino {
+    const obj: any = {};
+    obj.bech32_prefix = message.bech32Prefix === "" ? undefined : message.bech32Prefix;
+    if (message.moduleAccountPermissions) {
+      obj.module_account_permissions = message.moduleAccountPermissions.map(e => e ? ModuleAccountPermission.toAmino(e) : undefined);
+    } else {
+      obj.module_account_permissions = message.moduleAccountPermissions;
+    }
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    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.auth.module.v1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Module.typeUrl, Module);
+GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);
+function createBaseModuleAccountPermission(): ModuleAccountPermission {
+  return {
+    account: "",
+    permissions: []
+  };
+}
+export const ModuleAccountPermission = {
+  typeUrl: "/cosmos.auth.module.v1.ModuleAccountPermission",
+  aminoType: "cosmos-sdk/ModuleAccountPermission",
+  is(o: any): o is ModuleAccountPermission {
+    return o && (o.$typeUrl === ModuleAccountPermission.typeUrl || typeof o.account === "string" && Array.isArray(o.permissions) && (!o.permissions.length || typeof o.permissions[0] === "string"));
+  },
+  isAmino(o: any): o is ModuleAccountPermissionAmino {
+    return o && (o.$typeUrl === ModuleAccountPermission.typeUrl || typeof o.account === "string" && Array.isArray(o.permissions) && (!o.permissions.length || typeof o.permissions[0] === "string"));
+  },
+  encode(message: ModuleAccountPermission, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.account !== "") {
+      writer.uint32(10).string(message.account);
+    }
+    for (const v of message.permissions) {
+      writer.uint32(18).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ModuleAccountPermission {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleAccountPermission();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.account = reader.string();
+          break;
+        case 2:
+          message.permissions.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<ModuleAccountPermission>): ModuleAccountPermission {
+    const message = createBaseModuleAccountPermission();
+    message.account = object.account ?? "";
+    message.permissions = object.permissions?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ModuleAccountPermissionAmino): ModuleAccountPermission {
+    const message = createBaseModuleAccountPermission();
+    if (object.account !== undefined && object.account !== null) {
+      message.account = object.account;
+    }
+    message.permissions = object.permissions?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: ModuleAccountPermission): ModuleAccountPermissionAmino {
+    const obj: any = {};
+    obj.account = message.account === "" ? undefined : message.account;
+    if (message.permissions) {
+      obj.permissions = message.permissions.map(e => e);
+    } else {
+      obj.permissions = message.permissions;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAccountPermissionAminoMsg): ModuleAccountPermission {
+    return ModuleAccountPermission.fromAmino(object.value);
+  },
+  toAminoMsg(message: ModuleAccountPermission): ModuleAccountPermissionAminoMsg {
+    return {
+      type: "cosmos-sdk/ModuleAccountPermission",
+      value: ModuleAccountPermission.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleAccountPermissionProtoMsg): ModuleAccountPermission {
+    return ModuleAccountPermission.decode(message.value);
+  },
+  toProto(message: ModuleAccountPermission): Uint8Array {
+    return ModuleAccountPermission.encode(message).finish();
+  },
+  toProtoMsg(message: ModuleAccountPermission): ModuleAccountPermissionProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.module.v1.ModuleAccountPermission",
+      value: ModuleAccountPermission.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(ModuleAccountPermission.typeUrl, ModuleAccountPermission);
+GlobalDecoderRegistry.registerAminoProtoMapping(ModuleAccountPermission.aminoType, ModuleAccountPermission.typeUrl);

package/src/cosmos/auth/v1beta1/accounts.ts

@@ -0,0 +1,226 @@
+import { Any, AnyAmino } from "../../../google/protobuf/any";
+import { BaseAccount, BaseAccountAmino } from "./auth";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * QueryLegacyAccount defines a query that can be implemented by an x/account
+ * to return an auth understandable representation of an account.
+ * This query is only used for accounts retro-compatibility at gRPC
+ * level, the state machine must not make any assumptions around this.
+ */
+export interface QueryLegacyAccount {}
+export interface QueryLegacyAccountProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryLegacyAccount";
+  value: Uint8Array;
+}
+/**
+ * QueryLegacyAccount defines a query that can be implemented by an x/account
+ * to return an auth understandable representation of an account.
+ * This query is only used for accounts retro-compatibility at gRPC
+ * level, the state machine must not make any assumptions around this.
+ */
+export interface QueryLegacyAccountAmino {}
+export interface QueryLegacyAccountAminoMsg {
+  type: "cosmos-sdk/QueryLegacyAccount";
+  value: QueryLegacyAccountAmino;
+}
+/**
+ * QueryLegacyAccountResponse defines the response type of the
+ * `QueryLegacyAccount` query.
+ */
+export interface QueryLegacyAccountResponse {
+  /**
+   * account represents the google.Protobuf.Any wrapped account
+   * the type wrapped by the any does not need to comply with the
+   * sdk.AccountI interface.
+   */
+  account?: Any;
+  /**
+   * base represents the account as a BaseAccount, this can return
+   * nil if the account cannot be represented as a BaseAccount.
+   * This is used in the gRPC QueryAccountInfo method.
+   */
+  base?: BaseAccount;
+}
+export interface QueryLegacyAccountResponseProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryLegacyAccountResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryLegacyAccountResponse defines the response type of the
+ * `QueryLegacyAccount` query.
+ */
+export interface QueryLegacyAccountResponseAmino {
+  /**
+   * account represents the google.Protobuf.Any wrapped account
+   * the type wrapped by the any does not need to comply with the
+   * sdk.AccountI interface.
+   */
+  account?: AnyAmino;
+  /**
+   * base represents the account as a BaseAccount, this can return
+   * nil if the account cannot be represented as a BaseAccount.
+   * This is used in the gRPC QueryAccountInfo method.
+   */
+  base?: BaseAccountAmino;
+}
+export interface QueryLegacyAccountResponseAminoMsg {
+  type: "cosmos-sdk/QueryLegacyAccountResponse";
+  value: QueryLegacyAccountResponseAmino;
+}
+function createBaseQueryLegacyAccount(): QueryLegacyAccount {
+  return {};
+}
+export const QueryLegacyAccount = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryLegacyAccount",
+  aminoType: "cosmos-sdk/QueryLegacyAccount",
+  is(o: any): o is QueryLegacyAccount {
+    return o && o.$typeUrl === QueryLegacyAccount.typeUrl;
+  },
+  isAmino(o: any): o is QueryLegacyAccountAmino {
+    return o && o.$typeUrl === QueryLegacyAccount.typeUrl;
+  },
+  encode(_: QueryLegacyAccount, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryLegacyAccount {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryLegacyAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<QueryLegacyAccount>): QueryLegacyAccount {
+    const message = createBaseQueryLegacyAccount();
+    return message;
+  },
+  fromAmino(_: QueryLegacyAccountAmino): QueryLegacyAccount {
+    const message = createBaseQueryLegacyAccount();
+    return message;
+  },
+  toAmino(_: QueryLegacyAccount): QueryLegacyAccountAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryLegacyAccountAminoMsg): QueryLegacyAccount {
+    return QueryLegacyAccount.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryLegacyAccount): QueryLegacyAccountAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryLegacyAccount",
+      value: QueryLegacyAccount.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryLegacyAccountProtoMsg): QueryLegacyAccount {
+    return QueryLegacyAccount.decode(message.value);
+  },
+  toProto(message: QueryLegacyAccount): Uint8Array {
+    return QueryLegacyAccount.encode(message).finish();
+  },
+  toProtoMsg(message: QueryLegacyAccount): QueryLegacyAccountProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryLegacyAccount",
+      value: QueryLegacyAccount.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryLegacyAccount.typeUrl, QueryLegacyAccount);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryLegacyAccount.aminoType, QueryLegacyAccount.typeUrl);
+function createBaseQueryLegacyAccountResponse(): QueryLegacyAccountResponse {
+  return {
+    account: undefined,
+    base: undefined
+  };
+}
+export const QueryLegacyAccountResponse = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryLegacyAccountResponse",
+  aminoType: "cosmos-sdk/QueryLegacyAccountResponse",
+  is(o: any): o is QueryLegacyAccountResponse {
+    return o && o.$typeUrl === QueryLegacyAccountResponse.typeUrl;
+  },
+  isAmino(o: any): o is QueryLegacyAccountResponseAmino {
+    return o && o.$typeUrl === QueryLegacyAccountResponse.typeUrl;
+  },
+  encode(message: QueryLegacyAccountResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.account !== undefined) {
+      Any.encode(message.account, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.base !== undefined) {
+      BaseAccount.encode(message.base, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryLegacyAccountResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryLegacyAccountResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.account = Any.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.base = BaseAccount.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<QueryLegacyAccountResponse>): QueryLegacyAccountResponse {
+    const message = createBaseQueryLegacyAccountResponse();
+    message.account = object.account !== undefined && object.account !== null ? Any.fromPartial(object.account) : undefined;
+    message.base = object.base !== undefined && object.base !== null ? BaseAccount.fromPartial(object.base) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryLegacyAccountResponseAmino): QueryLegacyAccountResponse {
+    const message = createBaseQueryLegacyAccountResponse();
+    if (object.account !== undefined && object.account !== null) {
+      message.account = Any.fromAmino(object.account);
+    }
+    if (object.base !== undefined && object.base !== null) {
+      message.base = BaseAccount.fromAmino(object.base);
+    }
+    return message;
+  },
+  toAmino(message: QueryLegacyAccountResponse): QueryLegacyAccountResponseAmino {
+    const obj: any = {};
+    obj.account = message.account ? Any.toAmino(message.account) : undefined;
+    obj.base = message.base ? BaseAccount.toAmino(message.base) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryLegacyAccountResponseAminoMsg): QueryLegacyAccountResponse {
+    return QueryLegacyAccountResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryLegacyAccountResponse): QueryLegacyAccountResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryLegacyAccountResponse",
+      value: QueryLegacyAccountResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryLegacyAccountResponseProtoMsg): QueryLegacyAccountResponse {
+    return QueryLegacyAccountResponse.decode(message.value);
+  },
+  toProto(message: QueryLegacyAccountResponse): Uint8Array {
+    return QueryLegacyAccountResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryLegacyAccountResponse): QueryLegacyAccountResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryLegacyAccountResponse",
+      value: QueryLegacyAccountResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryLegacyAccountResponse.typeUrl, QueryLegacyAccountResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(QueryLegacyAccountResponse.aminoType, QueryLegacyAccountResponse.typeUrl);