@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/authz/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,56 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgGrant, MsgGrantResponse, MsgExec, MsgExecResponse, MsgRevoke, MsgRevokeResponse } from "./tx";
+/** Msg defines the authz Msg service. */
+
+export interface Msg {
+  /**
+   * Grant grants the provided authorization to the grantee on the granter's
+   * account with the provided expiration time. If there is already a grant
+   * for the given (granter, grantee, Authorization) triple, then the grant
+   * will be overwritten.
+   */
+  grant(request: MsgGrant): Promise<MsgGrantResponse>;
+  /**
+   * Exec attempts to execute the provided messages using
+   * authorizations granted to the grantee. Each message should have only
+   * one signer corresponding to the granter of the authorization.
+   */
+
+  exec(request: MsgExec): Promise<MsgExecResponse>;
+  /**
+   * Revoke revokes any authorization corresponding to the provided method name on the
+   * granter's account that has been granted to the grantee.
+   */
+
+  revoke(request: MsgRevoke): Promise<MsgRevokeResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.grant = this.grant.bind(this);
+    this.exec = this.exec.bind(this);
+    this.revoke = this.revoke.bind(this);
+  }
+
+  grant(request: MsgGrant): Promise<MsgGrantResponse> {
+    const data = MsgGrant.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Grant", data);
+    return promise.then(data => MsgGrantResponse.decode(new _m0.Reader(data)));
+  }
+
+  exec(request: MsgExec): Promise<MsgExecResponse> {
+    const data = MsgExec.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Exec", data);
+    return promise.then(data => MsgExecResponse.decode(new _m0.Reader(data)));
+  }
+
+  revoke(request: MsgRevoke): Promise<MsgRevokeResponse> {
+    const data = MsgRevoke.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Revoke", data);
+    return promise.then(data => MsgRevokeResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/cosmos/authz/v1beta1/tx.ts

@@ -0,0 +1,390 @@
+import { Grant, GrantSDKType } from "./authz";
+import { Any, AnySDKType } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * MsgGrant is a request type for Grant method. It declares authorization to the grantee
+ * on behalf of the granter with the provided expiration time.
+ */
+
+export interface MsgGrant {
+  granter: string;
+  grantee: string;
+  grant?: Grant;
+}
+/**
+ * MsgGrant is a request type for Grant method. It declares authorization to the grantee
+ * on behalf of the granter with the provided expiration time.
+ */
+
+export interface MsgGrantSDKType {
+  granter: string;
+  grantee: string;
+  grant?: GrantSDKType;
+}
+/** MsgGrantResponse defines the Msg/MsgGrant response type. */
+
+export interface MsgGrantResponse {}
+/** MsgGrantResponse defines the Msg/MsgGrant response type. */
+
+export interface MsgGrantResponseSDKType {}
+/**
+ * MsgExec attempts to execute the provided messages using
+ * authorizations granted to the grantee. Each message should have only
+ * one signer corresponding to the granter of the authorization.
+ */
+
+export interface MsgExec {
+  grantee: string;
+  /**
+   * Execute Msg.
+   * The x/authz will try to find a grant matching (msg.signers[0], grantee, MsgTypeURL(msg))
+   * triple and validate it.
+   */
+
+  msgs: Any[];
+}
+/**
+ * MsgExec attempts to execute the provided messages using
+ * authorizations granted to the grantee. Each message should have only
+ * one signer corresponding to the granter of the authorization.
+ */
+
+export interface MsgExecSDKType {
+  grantee: string;
+  msgs: AnySDKType[];
+}
+/** MsgExecResponse defines the Msg/MsgExecResponse response type. */
+
+export interface MsgExecResponse {
+  results: Uint8Array[];
+}
+/** MsgExecResponse defines the Msg/MsgExecResponse response type. */
+
+export interface MsgExecResponseSDKType {
+  results: Uint8Array[];
+}
+/**
+ * MsgRevoke revokes any authorization with the provided sdk.Msg type on the
+ * granter's account with that has been granted to the grantee.
+ */
+
+export interface MsgRevoke {
+  granter: string;
+  grantee: string;
+  msgTypeUrl: string;
+}
+/**
+ * MsgRevoke revokes any authorization with the provided sdk.Msg type on the
+ * granter's account with that has been granted to the grantee.
+ */
+
+export interface MsgRevokeSDKType {
+  granter: string;
+  grantee: string;
+  msg_type_url: string;
+}
+/** MsgRevokeResponse defines the Msg/MsgRevokeResponse response type. */
+
+export interface MsgRevokeResponse {}
+/** MsgRevokeResponse defines the Msg/MsgRevokeResponse response type. */
+
+export interface MsgRevokeResponseSDKType {}
+
+function createBaseMsgGrant(): MsgGrant {
+  return {
+    granter: "",
+    grantee: "",
+    grant: undefined
+  };
+}
+
+export const MsgGrant = {
+  encode(message: MsgGrant, 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.grant !== undefined) {
+      Grant.encode(message.grant, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgGrant {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgGrant();
+
+    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.grant = Grant.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgGrant>): MsgGrant {
+    const message = createBaseMsgGrant();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.grant = object.grant !== undefined && object.grant !== null ? Grant.fromPartial(object.grant) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgGrantResponse(): MsgGrantResponse {
+  return {};
+}
+
+export const MsgGrantResponse = {
+  encode(_: MsgGrantResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgGrantResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgGrantResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgGrantResponse>): MsgGrantResponse {
+    const message = createBaseMsgGrantResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgExec(): MsgExec {
+  return {
+    grantee: "",
+    msgs: []
+  };
+}
+
+export const MsgExec = {
+  encode(message: MsgExec, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.grantee !== "") {
+      writer.uint32(10).string(message.grantee);
+    }
+
+    for (const v of message.msgs) {
+      Any.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgExec {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgExec();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.grantee = reader.string();
+          break;
+
+        case 2:
+          message.msgs.push(Any.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgExec>): MsgExec {
+    const message = createBaseMsgExec();
+    message.grantee = object.grantee ?? "";
+    message.msgs = object.msgs?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseMsgExecResponse(): MsgExecResponse {
+  return {
+    results: []
+  };
+}
+
+export const MsgExecResponse = {
+  encode(message: MsgExecResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.results) {
+      writer.uint32(10).bytes(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgExecResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgExecResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.results.push(reader.bytes());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgExecResponse>): MsgExecResponse {
+    const message = createBaseMsgExecResponse();
+    message.results = object.results?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseMsgRevoke(): MsgRevoke {
+  return {
+    granter: "",
+    grantee: "",
+    msgTypeUrl: ""
+  };
+}
+
+export const MsgRevoke = {
+  encode(message: MsgRevoke, 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.msgTypeUrl !== "") {
+      writer.uint32(26).string(message.msgTypeUrl);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRevoke {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRevoke();
+
+    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.msgTypeUrl = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgRevoke>): MsgRevoke {
+    const message = createBaseMsgRevoke();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgRevokeResponse(): MsgRevokeResponse {
+  return {};
+}
+
+export const MsgRevokeResponse = {
+  encode(_: MsgRevokeResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRevokeResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRevokeResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgRevokeResponse>): MsgRevokeResponse {
+    const message = createBaseMsgRevokeResponse();
+    return message;
+  }
+
+};

package/src/codegen/cosmos/bank/module/v1/module.ts

@@ -0,0 +1,76 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object of the bank module. */
+
+export interface Module {
+  /**
+   * blocked_module_accounts_override configures exceptional module accounts which should be blocked from receiving
+   * funds. If left empty it defaults to the list of account names supplied in the auth module configuration as
+   * module_account_permissions
+   */
+  blockedModuleAccountsOverride: string[];
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+
+  authority: string;
+}
+/** Module is the config object of the bank module. */
+
+export interface ModuleSDKType {
+  blocked_module_accounts_override: string[];
+  authority: string;
+}
+
+function createBaseModule(): Module {
+  return {
+    blockedModuleAccountsOverride: [],
+    authority: ""
+  };
+}
+
+export const Module = {
+  encode(message: Module, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.blockedModuleAccountsOverride) {
+      writer.uint32(10).string(v!);
+    }
+
+    if (message.authority !== "") {
+      writer.uint32(18).string(message.authority);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Module {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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.blockedModuleAccountsOverride.push(reader.string());
+          break;
+
+        case 2:
+          message.authority = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.blockedModuleAccountsOverride = object.blockedModuleAccountsOverride?.map(e => e) || [];
+    message.authority = object.authority ?? "";
+    return message;
+  }
+
+};

package/src/codegen/cosmos/bank/v1beta1/authz.ts

@@ -0,0 +1,87 @@
+import { Coin, CoinSDKType } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+
+export interface SendAuthorization {
+  spendLimit: Coin[];
+  /**
+   * allow_list specifies an optional list of addresses to whom the grantee can send tokens on behalf of the
+   * granter. If omitted, any recipient is allowed.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+
+  allowList: string[];
+}
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+
+export interface SendAuthorizationSDKType {
+  spend_limit: CoinSDKType[];
+  allow_list: string[];
+}
+
+function createBaseSendAuthorization(): SendAuthorization {
+  return {
+    spendLimit: [],
+    allowList: []
+  };
+}
+
+export const SendAuthorization = {
+  encode(message: SendAuthorization, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.spendLimit) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.allowList) {
+      writer.uint32(18).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SendAuthorization {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendAuthorization();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.spendLimit.push(Coin.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.allowList.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SendAuthorization>): SendAuthorization {
+    const message = createBaseSendAuthorization();
+    message.spendLimit = object.spendLimit?.map(e => Coin.fromPartial(e)) || [];
+    message.allowList = object.allowList?.map(e => e) || [];
+    return message;
+  }
+
+};