@xpla/xplajs 1.7.0-beta.0

package/src/cosmos/authz/v1beta1/tx.js

@@ -0,0 +1,516 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgRevokeResponse = exports.MsgRevoke = exports.MsgExecResponse = exports.MsgExec = exports.MsgGrantResponse = exports.MsgGrant = void 0;
+const authz_1 = require("./authz");
+const any_1 = require("../../../google/protobuf/any");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+const registry_1 = require("../../../registry");
+function createBaseMsgGrant() {
+    return {
+        granter: "",
+        grantee: "",
+        grant: authz_1.Grant.fromPartial({})
+    };
+}
+exports.MsgGrant = {
+    typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+    aminoType: "cosmos-sdk/MsgGrant",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgGrant.typeUrl || typeof o.granter === "string" && typeof o.grantee === "string" && authz_1.Grant.is(o.grant));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgGrant.typeUrl || typeof o.granter === "string" && typeof o.grantee === "string" && authz_1.Grant.isAmino(o.grant));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.granter !== "") {
+            writer.uint32(10).string(message.granter);
+        }
+        if (message.grantee !== "") {
+            writer.uint32(18).string(message.grantee);
+        }
+        if (message.grant !== undefined) {
+            authz_1.Grant.encode(message.grant, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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 = authz_1.Grant.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgGrant();
+        message.granter = object.granter ?? "";
+        message.grantee = object.grantee ?? "";
+        message.grant = object.grant !== undefined && object.grant !== null ? authz_1.Grant.fromPartial(object.grant) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgGrant();
+        if (object.granter !== undefined && object.granter !== null) {
+            message.granter = object.granter;
+        }
+        if (object.grantee !== undefined && object.grantee !== null) {
+            message.grantee = object.grantee;
+        }
+        if (object.grant !== undefined && object.grant !== null) {
+            message.grant = authz_1.Grant.fromAmino(object.grant);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.granter = message.granter === "" ? undefined : message.granter;
+        obj.grantee = message.grantee === "" ? undefined : message.grantee;
+        obj.grant = message.grant ? authz_1.Grant.toAmino(message.grant) : authz_1.Grant.toAmino(authz_1.Grant.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgGrant.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgGrant",
+            value: exports.MsgGrant.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgGrant.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgGrant.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+            value: exports.MsgGrant.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgGrant.typeUrl, exports.MsgGrant);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgGrant.aminoType, exports.MsgGrant.typeUrl);
+function createBaseMsgGrantResponse() {
+    return {};
+}
+exports.MsgGrantResponse = {
+    typeUrl: "/cosmos.authz.v1beta1.MsgGrantResponse",
+    aminoType: "cosmos-sdk/MsgGrantResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.MsgGrantResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MsgGrantResponse.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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(_) {
+        const message = createBaseMsgGrantResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgGrantResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgGrantResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgGrantResponse",
+            value: exports.MsgGrantResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgGrantResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgGrantResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.authz.v1beta1.MsgGrantResponse",
+            value: exports.MsgGrantResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgGrantResponse.typeUrl, exports.MsgGrantResponse);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgGrantResponse.aminoType, exports.MsgGrantResponse.typeUrl);
+function createBaseMsgExec() {
+    return {
+        grantee: "",
+        msgs: []
+    };
+}
+exports.MsgExec = {
+    typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+    aminoType: "cosmos-sdk/MsgExec",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgExec.typeUrl || typeof o.grantee === "string" && Array.isArray(o.msgs) && (!o.msgs.length || any_1.Any.is(o.msgs[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgExec.typeUrl || typeof o.grantee === "string" && Array.isArray(o.msgs) && (!o.msgs.length || any_1.Any.isAmino(o.msgs[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.grantee !== "") {
+            writer.uint32(10).string(message.grantee);
+        }
+        for (const v of message.msgs) {
+            any_1.Any.encode(registry_1.GlobalDecoderRegistry.wrapAny(v), writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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(registry_1.GlobalDecoderRegistry.unwrapAny(reader));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgExec();
+        message.grantee = object.grantee ?? "";
+        message.msgs = object.msgs?.map(e => registry_1.GlobalDecoderRegistry.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgExec();
+        if (object.grantee !== undefined && object.grantee !== null) {
+            message.grantee = object.grantee;
+        }
+        message.msgs = object.msgs?.map(e => registry_1.GlobalDecoderRegistry.fromAminoMsg(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.grantee = message.grantee === "" ? undefined : message.grantee;
+        if (message.msgs) {
+            obj.msgs = message.msgs.map(e => e ? registry_1.GlobalDecoderRegistry.toAminoMsg(e) : undefined);
+        }
+        else {
+            obj.msgs = message.msgs;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgExec.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgExec",
+            value: exports.MsgExec.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgExec.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgExec.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+            value: exports.MsgExec.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgExec.typeUrl, exports.MsgExec);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgExec.aminoType, exports.MsgExec.typeUrl);
+function createBaseMsgExecResponse() {
+    return {
+        results: []
+    };
+}
+exports.MsgExecResponse = {
+    typeUrl: "/cosmos.authz.v1beta1.MsgExecResponse",
+    aminoType: "cosmos-sdk/MsgExecResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgExecResponse.typeUrl || Array.isArray(o.results) && (!o.results.length || o.results[0] instanceof Uint8Array || typeof o.results[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgExecResponse.typeUrl || Array.isArray(o.results) && (!o.results.length || o.results[0] instanceof Uint8Array || typeof o.results[0] === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.results) {
+            writer.uint32(10).bytes(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
+        const message = createBaseMsgExecResponse();
+        message.results = object.results?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgExecResponse();
+        message.results = object.results?.map(e => (0, helpers_1.bytesFromBase64)(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.results) {
+            obj.results = message.results.map(e => (0, helpers_1.base64FromBytes)(e));
+        }
+        else {
+            obj.results = message.results;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgExecResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgExecResponse",
+            value: exports.MsgExecResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgExecResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgExecResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.authz.v1beta1.MsgExecResponse",
+            value: exports.MsgExecResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgExecResponse.typeUrl, exports.MsgExecResponse);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgExecResponse.aminoType, exports.MsgExecResponse.typeUrl);
+function createBaseMsgRevoke() {
+    return {
+        granter: "",
+        grantee: "",
+        msgTypeUrl: ""
+    };
+}
+exports.MsgRevoke = {
+    typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+    aminoType: "cosmos-sdk/MsgRevoke",
+    is(o) {
+        return o && (o.$typeUrl === exports.MsgRevoke.typeUrl || typeof o.granter === "string" && typeof o.grantee === "string" && typeof o.msgTypeUrl === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MsgRevoke.typeUrl || typeof o.granter === "string" && typeof o.grantee === "string" && typeof o.msg_type_url === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        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, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
+        const message = createBaseMsgRevoke();
+        message.granter = object.granter ?? "";
+        message.grantee = object.grantee ?? "";
+        message.msgTypeUrl = object.msgTypeUrl ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRevoke();
+        if (object.granter !== undefined && object.granter !== null) {
+            message.granter = object.granter;
+        }
+        if (object.grantee !== undefined && object.grantee !== null) {
+            message.grantee = object.grantee;
+        }
+        if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
+            message.msgTypeUrl = object.msg_type_url;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.granter = message.granter === "" ? undefined : message.granter;
+        obj.grantee = message.grantee === "" ? undefined : message.grantee;
+        obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgRevoke.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgRevoke",
+            value: exports.MsgRevoke.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgRevoke.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgRevoke.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+            value: exports.MsgRevoke.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgRevoke.typeUrl, exports.MsgRevoke);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgRevoke.aminoType, exports.MsgRevoke.typeUrl);
+function createBaseMsgRevokeResponse() {
+    return {};
+}
+exports.MsgRevokeResponse = {
+    typeUrl: "/cosmos.authz.v1beta1.MsgRevokeResponse",
+    aminoType: "cosmos-sdk/MsgRevokeResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.MsgRevokeResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MsgRevokeResponse.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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(_) {
+        const message = createBaseMsgRevokeResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRevokeResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgRevokeResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgRevokeResponse",
+            value: exports.MsgRevokeResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgRevokeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgRevokeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.authz.v1beta1.MsgRevokeResponse",
+            value: exports.MsgRevokeResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.MsgRevokeResponse.typeUrl, exports.MsgRevokeResponse);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.MsgRevokeResponse.aminoType, exports.MsgRevokeResponse.typeUrl);

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

@@ -0,0 +1,3 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.authz.v1beta1.MsgGrant", MsgGrant], ["/cosmos.authz.v1beta1.MsgExec", MsgExec], ["/cosmos.authz.v1beta1.MsgRevoke", MsgRevoke]];

package/src/cosmos/authz/v1beta1/tx.rpc.func.d.ts

@@ -0,0 +1,5 @@
+import { SigningClientResolver } from "../../../helper-func-types";
+import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
+export declare const createGrant: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgGrant, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createExec: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgExec, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createRevoke: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRevoke, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;

package/src/cosmos/authz/v1beta1/tx.rpc.func.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRevoke = exports.createExec = exports.createGrant = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const utils_1 = require("@interchainjs/cosmos/utils");
+const tx_1 = require("./tx");
+const createGrant = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgGrant.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgGrant),
+    converters: (0, utils_1.toConverters)(tx_1.MsgGrant)
+});
+exports.createGrant = createGrant;
+const createExec = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgExec.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgExec),
+    converters: (0, utils_1.toConverters)(tx_1.MsgExec)
+});
+exports.createExec = createExec;
+const createRevoke = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRevoke.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRevoke),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRevoke)
+});
+exports.createRevoke = createRevoke;

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

@@ -0,0 +1,21 @@
+import { buildTx, SigningClientResolver } from "../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
+export const createGrant = (clientResolver?: SigningClientResolver) => buildTx<MsgGrant>({
+  clientResolver,
+  typeUrl: MsgGrant.typeUrl,
+  encoders: toEncoders(MsgGrant),
+  converters: toConverters(MsgGrant)
+});
+export const createExec = (clientResolver?: SigningClientResolver) => buildTx<MsgExec>({
+  clientResolver,
+  typeUrl: MsgExec.typeUrl,
+  encoders: toEncoders(MsgExec),
+  converters: toConverters(MsgExec)
+});
+export const createRevoke = (clientResolver?: SigningClientResolver) => buildTx<MsgRevoke>({
+  clientResolver,
+  typeUrl: MsgRevoke.typeUrl,
+  encoders: toEncoders(MsgRevoke),
+  converters: toConverters(MsgRevoke)
+});

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

@@ -0,0 +1,57 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+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: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* 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 = async (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 BinaryReader(data)));
+  };
+  /* 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 = async (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 BinaryReader(data)));
+  };
+  /* Revoke revokes any authorization corresponding to the provided method name on the
+   granter's account that has been granted to the grantee. */
+  revoke = async (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 BinaryReader(data)));
+  };
+}
+export const createClientImpl = (rpc: TxRpc) => {
+  return new MsgClientImpl(rpc);
+};