@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/circuit/v1/tx.ts

@@ -0,0 +1,409 @@
+import { Permissions, PermissionsSDKType } from "./types";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** MsgAuthorizeCircuitBreaker defines the Msg/AuthorizeCircuitBreaker request type. */
+
+export interface MsgAuthorizeCircuitBreaker {
+  /**
+   * granter is the granter of the circuit breaker permissions and must have
+   * LEVEL_SUPER_ADMIN.
+   */
+  granter: string;
+  /** grantee is the account authorized with the provided permissions. */
+
+  grantee: string;
+  /**
+   * permissions are the circuit breaker permissions that the grantee receives.
+   * These will overwrite any existing permissions. LEVEL_NONE_UNSPECIFIED can
+   * be specified to revoke all permissions.
+   */
+
+  permissions?: Permissions;
+}
+/** MsgAuthorizeCircuitBreaker defines the Msg/AuthorizeCircuitBreaker request type. */
+
+export interface MsgAuthorizeCircuitBreakerSDKType {
+  granter: string;
+  grantee: string;
+  permissions?: PermissionsSDKType;
+}
+/** MsgAuthorizeCircuitBreakerResponse defines the Msg/AuthorizeCircuitBreaker response type. */
+
+export interface MsgAuthorizeCircuitBreakerResponse {
+  success: boolean;
+}
+/** MsgAuthorizeCircuitBreakerResponse defines the Msg/AuthorizeCircuitBreaker response type. */
+
+export interface MsgAuthorizeCircuitBreakerResponseSDKType {
+  success: boolean;
+}
+/** MsgTripCircuitBreaker defines the Msg/TripCircuitBreaker request type. */
+
+export interface MsgTripCircuitBreaker {
+  /** authority is the account authorized to trip the circuit breaker. */
+  authority: string;
+  /**
+   * msg_type_urls specifies a list of type URLs to immediately stop processing.
+   * IF IT IS LEFT EMPTY, ALL MSG PROCESSING WILL STOP IMMEDIATELY.
+   * This value is validated against the authority's permissions and if the
+   * authority does not have permissions to trip the specified msg type URLs
+   * (or all URLs), the operation will fail.
+   */
+
+  msgTypeUrls: string[];
+}
+/** MsgTripCircuitBreaker defines the Msg/TripCircuitBreaker request type. */
+
+export interface MsgTripCircuitBreakerSDKType {
+  authority: string;
+  msg_type_urls: string[];
+}
+/** MsgTripCircuitBreakerResponse defines the Msg/TripCircuitBreaker response type. */
+
+export interface MsgTripCircuitBreakerResponse {
+  success: boolean;
+}
+/** MsgTripCircuitBreakerResponse defines the Msg/TripCircuitBreaker response type. */
+
+export interface MsgTripCircuitBreakerResponseSDKType {
+  success: boolean;
+}
+/** MsgResetCircuitBreaker defines the Msg/ResetCircuitBreaker request type. */
+
+export interface MsgResetCircuitBreaker {
+  /** authority is the account authorized to trip or reset the circuit breaker. */
+  authority: string;
+  /**
+   * msg_type_urls specifies a list of Msg type URLs to resume processing. If
+   * it is left empty all Msg processing for type URLs that the account is
+   * authorized to trip will resume.
+   */
+
+  msgTypeUrls: string[];
+}
+/** MsgResetCircuitBreaker defines the Msg/ResetCircuitBreaker request type. */
+
+export interface MsgResetCircuitBreakerSDKType {
+  authority: string;
+  msg_type_urls: string[];
+}
+/** MsgResetCircuitBreakerResponse defines the Msg/ResetCircuitBreaker response type. */
+
+export interface MsgResetCircuitBreakerResponse {
+  success: boolean;
+}
+/** MsgResetCircuitBreakerResponse defines the Msg/ResetCircuitBreaker response type. */
+
+export interface MsgResetCircuitBreakerResponseSDKType {
+  success: boolean;
+}
+
+function createBaseMsgAuthorizeCircuitBreaker(): MsgAuthorizeCircuitBreaker {
+  return {
+    granter: "",
+    grantee: "",
+    permissions: undefined
+  };
+}
+
+export const MsgAuthorizeCircuitBreaker = {
+  encode(message: MsgAuthorizeCircuitBreaker, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+
+    if (message.permissions !== undefined) {
+      Permissions.encode(message.permissions, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAuthorizeCircuitBreaker {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAuthorizeCircuitBreaker();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+
+        case 2:
+          message.grantee = reader.string();
+          break;
+
+        case 3:
+          message.permissions = Permissions.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgAuthorizeCircuitBreaker>): MsgAuthorizeCircuitBreaker {
+    const message = createBaseMsgAuthorizeCircuitBreaker();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.permissions = object.permissions !== undefined && object.permissions !== null ? Permissions.fromPartial(object.permissions) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgAuthorizeCircuitBreakerResponse(): MsgAuthorizeCircuitBreakerResponse {
+  return {
+    success: false
+  };
+}
+
+export const MsgAuthorizeCircuitBreakerResponse = {
+  encode(message: MsgAuthorizeCircuitBreakerResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.success === true) {
+      writer.uint32(8).bool(message.success);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAuthorizeCircuitBreakerResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAuthorizeCircuitBreakerResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.success = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgAuthorizeCircuitBreakerResponse>): MsgAuthorizeCircuitBreakerResponse {
+    const message = createBaseMsgAuthorizeCircuitBreakerResponse();
+    message.success = object.success ?? false;
+    return message;
+  }
+
+};
+
+function createBaseMsgTripCircuitBreaker(): MsgTripCircuitBreaker {
+  return {
+    authority: "",
+    msgTypeUrls: []
+  };
+}
+
+export const MsgTripCircuitBreaker = {
+  encode(message: MsgTripCircuitBreaker, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    for (const v of message.msgTypeUrls) {
+      writer.uint32(18).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTripCircuitBreaker {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTripCircuitBreaker();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.msgTypeUrls.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgTripCircuitBreaker>): MsgTripCircuitBreaker {
+    const message = createBaseMsgTripCircuitBreaker();
+    message.authority = object.authority ?? "";
+    message.msgTypeUrls = object.msgTypeUrls?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseMsgTripCircuitBreakerResponse(): MsgTripCircuitBreakerResponse {
+  return {
+    success: false
+  };
+}
+
+export const MsgTripCircuitBreakerResponse = {
+  encode(message: MsgTripCircuitBreakerResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.success === true) {
+      writer.uint32(8).bool(message.success);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTripCircuitBreakerResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTripCircuitBreakerResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.success = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgTripCircuitBreakerResponse>): MsgTripCircuitBreakerResponse {
+    const message = createBaseMsgTripCircuitBreakerResponse();
+    message.success = object.success ?? false;
+    return message;
+  }
+
+};
+
+function createBaseMsgResetCircuitBreaker(): MsgResetCircuitBreaker {
+  return {
+    authority: "",
+    msgTypeUrls: []
+  };
+}
+
+export const MsgResetCircuitBreaker = {
+  encode(message: MsgResetCircuitBreaker, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    for (const v of message.msgTypeUrls) {
+      writer.uint32(26).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgResetCircuitBreaker {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgResetCircuitBreaker();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 3:
+          message.msgTypeUrls.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgResetCircuitBreaker>): MsgResetCircuitBreaker {
+    const message = createBaseMsgResetCircuitBreaker();
+    message.authority = object.authority ?? "";
+    message.msgTypeUrls = object.msgTypeUrls?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseMsgResetCircuitBreakerResponse(): MsgResetCircuitBreakerResponse {
+  return {
+    success: false
+  };
+}
+
+export const MsgResetCircuitBreakerResponse = {
+  encode(message: MsgResetCircuitBreakerResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.success === true) {
+      writer.uint32(8).bool(message.success);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgResetCircuitBreakerResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgResetCircuitBreakerResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.success = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgResetCircuitBreakerResponse>): MsgResetCircuitBreakerResponse {
+    const message = createBaseMsgResetCircuitBreakerResponse();
+    message.success = object.success ?? false;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/circuit/v1/types.ts

@@ -0,0 +1,290 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** Level is the permission level. */
+
+export enum Permissions_Level {
+  /**
+   * LEVEL_NONE_UNSPECIFIED - LEVEL_NONE_UNSPECIFIED indicates that the account will have no circuit
+   * breaker permissions.
+   */
+  LEVEL_NONE_UNSPECIFIED = 0,
+
+  /**
+   * LEVEL_SOME_MSGS - LEVEL_SOME_MSGS indicates that the account will have permission to
+   * trip or reset the circuit breaker for some Msg type URLs. If this level
+   * is chosen, a non-empty list of Msg type URLs must be provided in
+   * limit_type_urls.
+   */
+  LEVEL_SOME_MSGS = 1,
+
+  /**
+   * LEVEL_ALL_MSGS - LEVEL_ALL_MSGS indicates that the account can trip or reset the circuit
+   * breaker for Msg's of all type URLs.
+   */
+  LEVEL_ALL_MSGS = 2,
+
+  /**
+   * LEVEL_SUPER_ADMIN - LEVEL_SUPER_ADMIN indicates that the account can take all circuit breaker
+   * actions and can grant permissions to other accounts.
+   */
+  LEVEL_SUPER_ADMIN = 3,
+  UNRECOGNIZED = -1,
+}
+export const Permissions_LevelSDKType = Permissions_Level;
+export function permissions_LevelFromJSON(object: any): Permissions_Level {
+  switch (object) {
+    case 0:
+    case "LEVEL_NONE_UNSPECIFIED":
+      return Permissions_Level.LEVEL_NONE_UNSPECIFIED;
+
+    case 1:
+    case "LEVEL_SOME_MSGS":
+      return Permissions_Level.LEVEL_SOME_MSGS;
+
+    case 2:
+    case "LEVEL_ALL_MSGS":
+      return Permissions_Level.LEVEL_ALL_MSGS;
+
+    case 3:
+    case "LEVEL_SUPER_ADMIN":
+      return Permissions_Level.LEVEL_SUPER_ADMIN;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Permissions_Level.UNRECOGNIZED;
+  }
+}
+export function permissions_LevelToJSON(object: Permissions_Level): string {
+  switch (object) {
+    case Permissions_Level.LEVEL_NONE_UNSPECIFIED:
+      return "LEVEL_NONE_UNSPECIFIED";
+
+    case Permissions_Level.LEVEL_SOME_MSGS:
+      return "LEVEL_SOME_MSGS";
+
+    case Permissions_Level.LEVEL_ALL_MSGS:
+      return "LEVEL_ALL_MSGS";
+
+    case Permissions_Level.LEVEL_SUPER_ADMIN:
+      return "LEVEL_SUPER_ADMIN";
+
+    case Permissions_Level.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/**
+ * Permissions are the permissions that an account has to trip
+ * or reset the circuit breaker.
+ */
+
+export interface Permissions {
+  /** level is the level of permissions granted to this account. */
+  level: Permissions_Level;
+  /**
+   * limit_type_urls is used with LEVEL_SOME_MSGS to limit the lists of Msg type
+   * URLs that the account can trip. It is an error to use limit_type_urls with
+   * a level other than LEVEL_SOME_MSGS.
+   */
+
+  limitTypeUrls: string[];
+}
+/**
+ * Permissions are the permissions that an account has to trip
+ * or reset the circuit breaker.
+ */
+
+export interface PermissionsSDKType {
+  level: Permissions_Level;
+  limit_type_urls: string[];
+}
+/** GenesisAccountPermissions is the account permissions for the circuit breaker in genesis */
+
+export interface GenesisAccountPermissions {
+  address: string;
+  permissions?: Permissions;
+}
+/** GenesisAccountPermissions is the account permissions for the circuit breaker in genesis */
+
+export interface GenesisAccountPermissionsSDKType {
+  address: string;
+  permissions?: PermissionsSDKType;
+}
+/** GenesisState is the state that must be provided at genesis. */
+
+export interface GenesisState {
+  accountPermissions: GenesisAccountPermissions[];
+  disabledTypeUrls: string[];
+}
+/** GenesisState is the state that must be provided at genesis. */
+
+export interface GenesisStateSDKType {
+  account_permissions: GenesisAccountPermissionsSDKType[];
+  disabled_type_urls: string[];
+}
+
+function createBasePermissions(): Permissions {
+  return {
+    level: 0,
+    limitTypeUrls: []
+  };
+}
+
+export const Permissions = {
+  encode(message: Permissions, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.level !== 0) {
+      writer.uint32(8).int32(message.level);
+    }
+
+    for (const v of message.limitTypeUrls) {
+      writer.uint32(18).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Permissions {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePermissions();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.level = (reader.int32() as any);
+          break;
+
+        case 2:
+          message.limitTypeUrls.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Permissions>): Permissions {
+    const message = createBasePermissions();
+    message.level = object.level ?? 0;
+    message.limitTypeUrls = object.limitTypeUrls?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseGenesisAccountPermissions(): GenesisAccountPermissions {
+  return {
+    address: "",
+    permissions: undefined
+  };
+}
+
+export const GenesisAccountPermissions = {
+  encode(message: GenesisAccountPermissions, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    if (message.permissions !== undefined) {
+      Permissions.encode(message.permissions, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisAccountPermissions {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisAccountPermissions();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+
+        case 2:
+          message.permissions = Permissions.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisAccountPermissions>): GenesisAccountPermissions {
+    const message = createBaseGenesisAccountPermissions();
+    message.address = object.address ?? "";
+    message.permissions = object.permissions !== undefined && object.permissions !== null ? Permissions.fromPartial(object.permissions) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    accountPermissions: [],
+    disabledTypeUrls: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.accountPermissions) {
+      GenesisAccountPermissions.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.disabledTypeUrls) {
+      writer.uint32(18).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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.accountPermissions.push(GenesisAccountPermissions.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.disabledTypeUrls.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.accountPermissions = object.accountPermissions?.map(e => GenesisAccountPermissions.fromPartial(e)) || [];
+    message.disabledTypeUrls = object.disabledTypeUrls?.map(e => e) || [];
+    return message;
+  }
+
+};