decentralcardgame-cardchain-client-ts 0.0.8 → 0.0.10

package/cosmos.auth.v1beta1/types/cosmos/auth/v1beta1/auth.ts

@@ -24,6 +24,21 @@ export interface ModuleAccount {
   permissions: string[];
 }
 
+/**
+ * ModuleCredential represents a unclaimable pubkey for base accounts controlled by modules.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface ModuleCredential {
+  /** module_name is the name of the module used for address derivation (passed into address.Module). */
+  moduleName: string;
+  /**
+   * derivation_keys is for deriving a module account address (passed into address.Module)
+   * adding more keys creates sub-account addresses (passed into address.Derive)
+   */
+  derivationKeys: Uint8Array[];
+}
+
 /** Params defines the parameters for the auth module. */
 export interface Params {
   maxMemoCharacters: number;
@@ -185,6 +200,70 @@ export const ModuleAccount = {
   },
 };
 
+function createBaseModuleCredential(): ModuleCredential {
+  return { moduleName: "", derivationKeys: [] };
+}
+
+export const ModuleCredential = {
+  encode(message: ModuleCredential, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.moduleName !== "") {
+      writer.uint32(10).string(message.moduleName);
+    }
+    for (const v of message.derivationKeys) {
+      writer.uint32(18).bytes(v!);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ModuleCredential {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleCredential();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.moduleName = reader.string();
+          break;
+        case 2:
+          message.derivationKeys.push(reader.bytes());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ModuleCredential {
+    return {
+      moduleName: isSet(object.moduleName) ? String(object.moduleName) : "",
+      derivationKeys: Array.isArray(object?.derivationKeys)
+        ? object.derivationKeys.map((e: any) => bytesFromBase64(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ModuleCredential): unknown {
+    const obj: any = {};
+    message.moduleName !== undefined && (obj.moduleName = message.moduleName);
+    if (message.derivationKeys) {
+      obj.derivationKeys = message.derivationKeys.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array()));
+    } else {
+      obj.derivationKeys = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ModuleCredential>, I>>(object: I): ModuleCredential {
+    const message = createBaseModuleCredential();
+    message.moduleName = object.moduleName ?? "";
+    message.derivationKeys = object.derivationKeys?.map((e) => e) || [];
+    return message;
+  },
+};
+
 function createBaseParams(): Params {
   return {
     maxMemoCharacters: 0,
@@ -296,6 +375,31 @@ var globalThis: any = (() => {
   throw "Unable to locate global object";
 })();
 
+function bytesFromBase64(b64: string): Uint8Array {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 
 export type DeepPartial<T> = T extends Builtin ? T

package/cosmos.auth.v1beta1/types/cosmos/auth/v1beta1/genesis.ts

@@ -7,7 +7,7 @@ export const protobufPackage = "cosmos.auth.v1beta1";
 
 /** GenesisState defines the auth module's genesis state. */
 export interface GenesisState {
-  /** params defines all the paramaters of the module. */
+  /** params defines all the parameters of the module. */
   params:
     | Params
     | undefined;

package/cosmos.auth.v1beta1/types/cosmos/auth/v1beta1/query.ts

@@ -3,7 +3,7 @@ import Long from "long";
 import _m0 from "protobufjs/minimal";
 import { Any } from "../../../google/protobuf/any";
 import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
-import { Params } from "./auth";
+import { BaseAccount, Params } from "./auth";
 
 export const protobufPackage = "cosmos.auth.v1beta1";
 
@@ -138,11 +138,21 @@ export interface AddressStringToBytesResponse {
  */
 export interface QueryAccountAddressByIDRequest {
   /**
+   * Deprecated, use account_id instead
+   *
    * id is the account number of the address to be queried. This field
    * should have been an uint64 (like all account numbers), and will be
    * updated to uint64 in a future version of the auth query.
+   *
+   * @deprecated
    */
   id: number;
+  /**
+   * account_id is the account number of the address to be queried.
+   *
+   * Since: cosmos-sdk 0.47
+   */
+  accountId: number;
 }
 
 /**
@@ -154,6 +164,26 @@ export interface QueryAccountAddressByIDResponse {
   accountAddress: string;
 }
 
+/**
+ * QueryAccountInfoRequest is the Query/AccountInfo request type.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface QueryAccountInfoRequest {
+  /** address is the account address string. */
+  address: string;
+}
+
+/**
+ * QueryAccountInfoResponse is the Query/AccountInfo response type.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface QueryAccountInfoResponse {
+  /** info is the account info which is represented by BaseAccount. */
+  info: BaseAccount | undefined;
+}
+
 function createBaseQueryAccountsRequest(): QueryAccountsRequest {
   return { pagination: undefined };
 }
@@ -924,7 +954,7 @@ export const AddressStringToBytesResponse = {
 };
 
 function createBaseQueryAccountAddressByIDRequest(): QueryAccountAddressByIDRequest {
-  return { id: 0 };
+  return { id: 0, accountId: 0 };
 }
 
 export const QueryAccountAddressByIDRequest = {
@@ -932,6 +962,9 @@ export const QueryAccountAddressByIDRequest = {
     if (message.id !== 0) {
       writer.uint32(8).int64(message.id);
     }
+    if (message.accountId !== 0) {
+      writer.uint32(16).uint64(message.accountId);
+    }
     return writer;
   },
 
@@ -945,6 +978,9 @@ export const QueryAccountAddressByIDRequest = {
         case 1:
           message.id = longToNumber(reader.int64() as Long);
           break;
+        case 2:
+          message.accountId = longToNumber(reader.uint64() as Long);
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -954,12 +990,16 @@ export const QueryAccountAddressByIDRequest = {
   },
 
   fromJSON(object: any): QueryAccountAddressByIDRequest {
-    return { id: isSet(object.id) ? Number(object.id) : 0 };
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      accountId: isSet(object.accountId) ? Number(object.accountId) : 0,
+    };
   },
 
   toJSON(message: QueryAccountAddressByIDRequest): unknown {
     const obj: any = {};
     message.id !== undefined && (obj.id = Math.round(message.id));
+    message.accountId !== undefined && (obj.accountId = Math.round(message.accountId));
     return obj;
   },
 
@@ -968,6 +1008,7 @@ export const QueryAccountAddressByIDRequest = {
   ): QueryAccountAddressByIDRequest {
     const message = createBaseQueryAccountAddressByIDRequest();
     message.id = object.id ?? 0;
+    message.accountId = object.accountId ?? 0;
     return message;
   },
 };
@@ -1021,10 +1062,109 @@ export const QueryAccountAddressByIDResponse = {
   },
 };
 
+function createBaseQueryAccountInfoRequest(): QueryAccountInfoRequest {
+  return { address: "" };
+}
+
+export const QueryAccountInfoRequest = {
+  encode(message: QueryAccountInfoRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountInfoRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAccountInfoRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryAccountInfoRequest {
+    return { address: isSet(object.address) ? String(object.address) : "" };
+  },
+
+  toJSON(message: QueryAccountInfoRequest): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<QueryAccountInfoRequest>, I>>(object: I): QueryAccountInfoRequest {
+    const message = createBaseQueryAccountInfoRequest();
+    message.address = object.address ?? "";
+    return message;
+  },
+};
+
+function createBaseQueryAccountInfoResponse(): QueryAccountInfoResponse {
+  return { info: undefined };
+}
+
+export const QueryAccountInfoResponse = {
+  encode(message: QueryAccountInfoResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.info !== undefined) {
+      BaseAccount.encode(message.info, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountInfoResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAccountInfoResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.info = BaseAccount.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryAccountInfoResponse {
+    return { info: isSet(object.info) ? BaseAccount.fromJSON(object.info) : undefined };
+  },
+
+  toJSON(message: QueryAccountInfoResponse): unknown {
+    const obj: any = {};
+    message.info !== undefined && (obj.info = message.info ? BaseAccount.toJSON(message.info) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<QueryAccountInfoResponse>, I>>(object: I): QueryAccountInfoResponse {
+    const message = createBaseQueryAccountInfoResponse();
+    message.info = (object.info !== undefined && object.info !== null)
+      ? BaseAccount.fromPartial(object.info)
+      : undefined;
+    return message;
+  },
+};
+
 /** Query defines the gRPC querier service. */
 export interface Query {
   /**
-   * Accounts returns all the existing accounts
+   * Accounts returns all the existing accounts.
+   *
+   * When called from another module, this query might consume a high amount of
+   * gas if the pagination field is incorrectly set.
    *
    * Since: cosmos-sdk 0.43
    */
@@ -1065,6 +1205,12 @@ export interface Query {
    * Since: cosmos-sdk 0.46
    */
   AddressStringToBytes(request: AddressStringToBytesRequest): Promise<AddressStringToBytesResponse>;
+  /**
+   * AccountInfo queries account info which is common to all account types.
+   *
+   * Since: cosmos-sdk 0.47
+   */
+  AccountInfo(request: QueryAccountInfoRequest): Promise<QueryAccountInfoResponse>;
 }
 
 export class QueryClientImpl implements Query {
@@ -1080,6 +1226,7 @@ export class QueryClientImpl implements Query {
     this.Bech32Prefix = this.Bech32Prefix.bind(this);
     this.AddressBytesToString = this.AddressBytesToString.bind(this);
     this.AddressStringToBytes = this.AddressStringToBytes.bind(this);
+    this.AccountInfo = this.AccountInfo.bind(this);
   }
   Accounts(request: QueryAccountsRequest): Promise<QueryAccountsResponse> {
     const data = QueryAccountsRequest.encode(request).finish();
@@ -1134,6 +1281,12 @@ export class QueryClientImpl implements Query {
     const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "AddressStringToBytes", data);
     return promise.then((data) => AddressStringToBytesResponse.decode(new _m0.Reader(data)));
   }
+
+  AccountInfo(request: QueryAccountInfoRequest): Promise<QueryAccountInfoResponse> {
+    const data = QueryAccountInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "AccountInfo", data);
+    return promise.then((data) => QueryAccountInfoResponse.decode(new _m0.Reader(data)));
+  }
 }
 
 interface Rpc {

package/cosmos.auth.v1beta1/types/cosmos/auth/v1beta1/tx.ts

@@ -0,0 +1,172 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Params } from "./auth";
+
+export const protobufPackage = "cosmos.auth.v1beta1";
+
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParams {
+  /** authority is the address that controls the module (defaults to x/gov unless overwritten). */
+  authority: string;
+  /**
+   * params defines the x/auth parameters to update.
+   *
+   * NOTE: All parameters must be supplied.
+   */
+  params: Params | undefined;
+}
+
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParamsResponse {
+}
+
+function createBaseMsgUpdateParams(): MsgUpdateParams {
+  return { authority: "", params: undefined };
+}
+
+export const MsgUpdateParams = {
+  encode(message: MsgUpdateParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParams();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+        case 2:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateParams {
+    return {
+      authority: isSet(object.authority) ? String(object.authority) : "",
+      params: isSet(object.params) ? Params.fromJSON(object.params) : undefined,
+    };
+  },
+
+  toJSON(message: MsgUpdateParams): unknown {
+    const obj: any = {};
+    message.authority !== undefined && (obj.authority = message.authority);
+    message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateParams>, I>>(object: I): MsgUpdateParams {
+    const message = createBaseMsgUpdateParams();
+    message.authority = object.authority ?? "";
+    message.params = (object.params !== undefined && object.params !== null)
+      ? Params.fromPartial(object.params)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseMsgUpdateParamsResponse(): MsgUpdateParamsResponse {
+  return {};
+}
+
+export const MsgUpdateParamsResponse = {
+  encode(_: MsgUpdateParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateParamsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParamsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUpdateParamsResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUpdateParamsResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateParamsResponse>, I>>(_: I): MsgUpdateParamsResponse {
+    const message = createBaseMsgUpdateParamsResponse();
+    return message;
+  },
+};
+
+/** Msg defines the x/auth Msg service. */
+export interface Msg {
+  /**
+   * UpdateParams defines a (governance) operation for updating the x/auth module
+   * parameters. The authority defaults to the x/gov module account.
+   *
+   * Since: cosmos-sdk 0.47
+   */
+  UpdateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.UpdateParams = this.UpdateParams.bind(this);
+  }
+  UpdateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse> {
+    const data = MsgUpdateParams.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Msg", "UpdateParams", data);
+    return promise.then((data) => MsgUpdateParamsResponse.decode(new _m0.Reader(data)));
+  }
+}
+
+interface Rpc {
+  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/cosmos.auth.v1beta1/types/cosmos/query/v1/query.ts

@@ -0,0 +1,2 @@
+/* eslint-disable */
+export const protobufPackage = "cosmos.query.v1";

package/cosmos.auth.v1beta1/types.ts

@@ -1,11 +1,13 @@
 import { BaseAccount } from "./types/cosmos/auth/v1beta1/auth"
 import { ModuleAccount } from "./types/cosmos/auth/v1beta1/auth"
+import { ModuleCredential } from "./types/cosmos/auth/v1beta1/auth"
 import { Params } from "./types/cosmos/auth/v1beta1/auth"
 
 
 export {     
     BaseAccount,
     ModuleAccount,
+    ModuleCredential,
     Params,
     
  }

package/cosmos.authz.v1beta1/module.ts

@@ -7,9 +7,9 @@ import { msgTypes } from './registry';
 import { IgniteClient } from "../client"
 import { MissingWalletError } from "../helpers"
 import { Api } from "./rest";
+import { MsgGrant } from "./types/cosmos/authz/v1beta1/tx";
 import { MsgExec } from "./types/cosmos/authz/v1beta1/tx";
 import { MsgRevoke } from "./types/cosmos/authz/v1beta1/tx";
-import { MsgGrant } from "./types/cosmos/authz/v1beta1/tx";
 
 import { GenericAuthorization as typeGenericAuthorization} from "./types"
 import { Grant as typeGrant} from "./types"
@@ -18,7 +18,13 @@ import { GrantQueueItem as typeGrantQueueItem} from "./types"
 import { EventGrant as typeEventGrant} from "./types"
 import { EventRevoke as typeEventRevoke} from "./types"
 
-export { MsgExec, MsgRevoke, MsgGrant };
+export { MsgGrant, MsgExec, MsgRevoke };
+
+type sendMsgGrantParams = {
+  value: MsgGrant,
+  fee?: StdFee,
+  memo?: string
+};
 
 type sendMsgExecParams = {
   value: MsgExec,
@@ -32,13 +38,11 @@ type sendMsgRevokeParams = {
   memo?: string
 };
 
-type sendMsgGrantParams = {
+
+type msgGrantParams = {
   value: MsgGrant,
-  fee?: StdFee,
-  memo?: string
 };
 
-
 type msgExecParams = {
   value: MsgExec,
 };
@@ -47,10 +51,6 @@ type msgRevokeParams = {
   value: MsgRevoke,
 };
 
-type msgGrantParams = {
-  value: MsgGrant,
-};
-
 
 export const registry = new Registry(msgTypes);
 
@@ -81,6 +81,20 @@ export const txClient = ({ signer, prefix, addr }: TxClientOptions = { addr: "ht
 
   return {
 		
+		async sendMsgGrant({ value, fee, memo }: sendMsgGrantParams): Promise<DeliverTxResponse> {
+			if (!signer) {
+					throw new Error('TxClient:sendMsgGrant: Unable to sign Tx. Signer is not present.')
+			}
+			try {			
+				const { address } = (await signer.getAccounts())[0]; 
+				const signingClient = await SigningStargateClient.connectWithSigner(addr,signer,{registry, prefix});
+				let msg = this.msgGrant({ value: MsgGrant.fromPartial(value) })
+				return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
+			} catch (e: any) {
+				throw new Error('TxClient:sendMsgGrant: Could not broadcast Tx: '+ e.message)
+			}
+		},
+		
 		async sendMsgExec({ value, fee, memo }: sendMsgExecParams): Promise<DeliverTxResponse> {
 			if (!signer) {
 					throw new Error('TxClient:sendMsgExec: Unable to sign Tx. Signer is not present.')
@@ -109,21 +123,15 @@ export const txClient = ({ signer, prefix, addr }: TxClientOptions = { addr: "ht
 			}
 		},
 		
-		async sendMsgGrant({ value, fee, memo }: sendMsgGrantParams): Promise<DeliverTxResponse> {
-			if (!signer) {
-					throw new Error('TxClient:sendMsgGrant: Unable to sign Tx. Signer is not present.')
-			}
-			try {			
-				const { address } = (await signer.getAccounts())[0]; 
-				const signingClient = await SigningStargateClient.connectWithSigner(addr,signer,{registry, prefix});
-				let msg = this.msgGrant({ value: MsgGrant.fromPartial(value) })
-				return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
+		
+		msgGrant({ value }: msgGrantParams): EncodeObject {
+			try {
+				return { typeUrl: "/cosmos.authz.v1beta1.MsgGrant", value: MsgGrant.fromPartial( value ) }  
 			} catch (e: any) {
-				throw new Error('TxClient:sendMsgGrant: Could not broadcast Tx: '+ e.message)
+				throw new Error('TxClient:MsgGrant: Could not create message: ' + e.message)
 			}
 		},
 		
-		
 		msgExec({ value }: msgExecParams): EncodeObject {
 			try {
 				return { typeUrl: "/cosmos.authz.v1beta1.MsgExec", value: MsgExec.fromPartial( value ) }  
@@ -140,14 +148,6 @@ export const txClient = ({ signer, prefix, addr }: TxClientOptions = { addr: "ht
 			}
 		},
 		
-		msgGrant({ value }: msgGrantParams): EncodeObject {
-			try {
-				return { typeUrl: "/cosmos.authz.v1beta1.MsgGrant", value: MsgGrant.fromPartial( value ) }  
-			} catch (e: any) {
-				throw new Error('TxClient:MsgGrant: Could not create message: ' + e.message)
-			}
-		},
-		
 	}
 };