@kimafinance/kima-transaction-api 1.0.0 → 1.0.1

package/src/kima/tx.ts

@@ -1,2190 +1,3486 @@
 /* eslint-disable */
-import { Reader, Writer } from 'protobufjs/minimal'
+import { Reader, Writer } from "protobufjs/minimal";
 
-export const protobufPackage = 'DiversifiTechnologies.diversifi.diversifi'
+export const protobufPackage = "KimaFinance.kima.kima";
 
 export interface MsgRequestTransaction {
-  creator: string
-  originChain: string
-  originAddress: string
-  targetChain: string
-  targetAddress: string
-  amount: string
-  fee: string
+  creator: string;
+  originChain: string;
+  originAddress: string;
+  targetChain: string;
+  targetAddress: string;
+  symbol: string;
+  amount: string;
+  fee: string;
 }
 
 export interface MsgRequestTransactionResponse {
-  code: string
-  msg: string
+  code: string;
+  msg: string;
+  txId: string;
 }
 
 export interface MsgApproveTransaction {
-  creator: string
-  txHash: string
-  success: string
-  signedKey: string
+  creator: string;
+  txHash: string;
+  success: string;
+  signedKey: string;
 }
 
 export interface MsgApproveTransactionResponse {
-  code: string
-  msg: string
+  code: string;
+  msg: string;
 }
 
 export interface MsgFetchBalance {
-  creator: string
+  creator: string;
 }
 
 export interface MsgFetchBalanceResponse {
-  code: string
-  result: string
+  code: string;
+  result: string;
 }
 
 export interface MsgObservationVote {
-  creator: string
-  txHash: string
-  chainId: string
-  from: string
-  to: string
-  amount: string
+  creator: string;
+  txHash: string;
+  chainId: string;
+  from: string;
+  to: string;
+  amount: string;
 }
 
 export interface MsgObservationVoteResponse {
-  code: string
-  msg: string
+  code: string;
+  msg: string;
 }
 
 export interface MsgUpdateBalance {
-  creator: string
-  chainId: string
-  balance: string
-  decimal: string
+  creator: string;
+  chainId: string;
+  balance: string;
+  decimal: string;
 }
 
 export interface MsgUpdateBalanceResponse {
-  code: string
-  msg: string
+  code: string;
+  msg: string;
 }
 
 export interface MsgKeysignVote {
-  creator: string
-  txHash: string
-  pubKey: string
+  creator: string;
+  txHash: string;
+  pubKey: string;
 }
 
 export interface MsgKeysignVoteResponse {
-  code: string
-  msg: string
+  code: string;
+  msg: string;
 }
 
 export interface MsgUpdateGasFee {
-  creator: string
-  chainId: string
-  fee: string
+  creator: string;
+  chainId: string;
+  fee: string;
 }
 
-export interface MsgUpdateGasFeeResponse {}
+export interface MsgUpdateGasFeeResponse {
+  code: string;
+  msg: string;
+}
 
 export interface MsgProvisionTransaction {
-  creator: string
-  fromChain: string
-  fromAddress: string
-  symbol: string
-  tokenAddr: string
-  amount: string
-  options: string
+  creator: string;
+  fromChain: string;
+  fromAddress: string;
+  symbol: string;
+  tokenAddr: string;
+  amount: string;
+  options: string;
 }
 
-export interface MsgProvisionTransactionResponse {}
+export interface MsgProvisionTransactionResponse {
+  code: string;
+  msg: string;
+}
 
 export interface MsgDrainTransaction {
-  creator: string
-  fromChain: string
-  toChain: string
-  toAddress: string
-  nftAddr: string
-  amount: string
-  options: string
+  creator: string;
+  fromChain: string;
+  toChain: string;
+  toAddress: string;
+  nftAddr: string;
+  amount: string;
+  options: string;
 }
 
-export interface MsgDrainTransactionResponse {}
+export interface MsgDrainTransactionResponse {
+  code: string;
+  msg: string;
+}
 
 export interface MsgCancelTransaction {
-  creator: string
-  transactionId: string
+  creator: string;
+  transactionId: string;
+}
+
+export interface MsgCancelTransactionResponse {
+  code: string;
+  msg: string;
 }
 
-export interface MsgCancelTransactionResponse {}
+export interface MsgAddWhitelisted {
+  creator: string;
+  address: string;
+}
 
-const baseMsgRequestTransaction: object = {
-  creator: '',
-  originChain: '',
-  originAddress: '',
-  targetChain: '',
-  targetAddress: '',
-  amount: '',
-  fee: ''
+export interface MsgAddWhitelistedResponse {
+  code: string;
+  msg: string;
+}
+
+export interface MsgSetAdmin {
+  creator: string;
+}
+
+export interface MsgSetAdminResponse {
+  code: string;
+  msg: string;
+}
+
+export interface MsgAddPubkey {
+  creator: string;
+  pubkey: string;
+}
+
+export interface MsgAddPubkeyResponse {
+  code: string;
+  msg: string;
+}
+
+export interface MsgUpdateTssPubkey {
+  creator: string;
+  tssPubkey: string;
+  ecdsa: string;
+  ebdsa: string;
+  reserved: string;
+}
+
+export interface MsgUpdateTssPubkeyResponse {
+  code: string;
+  msg: string;
+}
+
+export interface MsgRemoveWhitelisted {
+  creator: string;
+  address: string;
+}
+
+export interface MsgRemoveWhitelistedResponse {
+  code: string;
+  msg: string;
+}
+
+export interface MsgClearTssInfo {
+  creator: string;
+}
+
+export interface MsgClearTssInfoResponse {
+  code: string;
+  msg: string;
 }
 
+const baseMsgRequestTransaction: object = {
+  creator: "",
+  originChain: "",
+  originAddress: "",
+  targetChain: "",
+  targetAddress: "",
+  symbol: "",
+  amount: "",
+  fee: "",
+};
+
 export const MsgRequestTransaction = {
   encode(
     message: MsgRequestTransaction,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.originChain !== "") {
+      writer.uint32(18).string(message.originChain);
     }
-    if (message.originChain !== '') {
-      writer.uint32(18).string(message.originChain)
+    if (message.originAddress !== "") {
+      writer.uint32(26).string(message.originAddress);
     }
-    if (message.originAddress !== '') {
-      writer.uint32(26).string(message.originAddress)
+    if (message.targetChain !== "") {
+      writer.uint32(34).string(message.targetChain);
     }
-    if (message.targetChain !== '') {
-      writer.uint32(34).string(message.targetChain)
+    if (message.targetAddress !== "") {
+      writer.uint32(42).string(message.targetAddress);
     }
-    if (message.targetAddress !== '') {
-      writer.uint32(42).string(message.targetAddress)
+    if (message.symbol !== "") {
+      writer.uint32(50).string(message.symbol);
     }
-    if (message.amount !== '') {
-      writer.uint32(50).string(message.amount)
+    if (message.amount !== "") {
+      writer.uint32(58).string(message.amount);
     }
-    if (message.fee !== '') {
-      writer.uint32(58).string(message.fee)
+    if (message.fee !== "") {
+      writer.uint32(66).string(message.fee);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgRequestTransaction {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgRequestTransaction } as MsgRequestTransaction
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgRequestTransaction } as MsgRequestTransaction;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.originChain = reader.string()
-          break
+          message.originChain = reader.string();
+          break;
         case 3:
-          message.originAddress = reader.string()
-          break
+          message.originAddress = reader.string();
+          break;
         case 4:
-          message.targetChain = reader.string()
-          break
+          message.targetChain = reader.string();
+          break;
         case 5:
-          message.targetAddress = reader.string()
-          break
+          message.targetAddress = reader.string();
+          break;
         case 6:
-          message.amount = reader.string()
-          break
+          message.symbol = reader.string();
+          break;
         case 7:
-          message.fee = reader.string()
-          break
+          message.amount = reader.string();
+          break;
+        case 8:
+          message.fee = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgRequestTransaction {
-    const message = { ...baseMsgRequestTransaction } as MsgRequestTransaction
+    const message = { ...baseMsgRequestTransaction } as MsgRequestTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.originChain !== undefined && object.originChain !== null) {
-      message.originChain = String(object.originChain)
+      message.originChain = String(object.originChain);
     } else {
-      message.originChain = ''
+      message.originChain = "";
     }
     if (object.originAddress !== undefined && object.originAddress !== null) {
-      message.originAddress = String(object.originAddress)
+      message.originAddress = String(object.originAddress);
     } else {
-      message.originAddress = ''
+      message.originAddress = "";
     }
     if (object.targetChain !== undefined && object.targetChain !== null) {
-      message.targetChain = String(object.targetChain)
+      message.targetChain = String(object.targetChain);
     } else {
-      message.targetChain = ''
+      message.targetChain = "";
     }
     if (object.targetAddress !== undefined && object.targetAddress !== null) {
-      message.targetAddress = String(object.targetAddress)
+      message.targetAddress = String(object.targetAddress);
+    } else {
+      message.targetAddress = "";
+    }
+    if (object.symbol !== undefined && object.symbol !== null) {
+      message.symbol = String(object.symbol);
     } else {
-      message.targetAddress = ''
+      message.symbol = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = String(object.amount)
+      message.amount = String(object.amount);
     } else {
-      message.amount = ''
+      message.amount = "";
     }
     if (object.fee !== undefined && object.fee !== null) {
-      message.fee = String(object.fee)
+      message.fee = String(object.fee);
     } else {
-      message.fee = ''
+      message.fee = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgRequestTransaction): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.originChain !== undefined && (obj.originChain = message.originChain)
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.originChain !== undefined &&
+      (obj.originChain = message.originChain);
     message.originAddress !== undefined &&
-      (obj.originAddress = message.originAddress)
-    message.targetChain !== undefined && (obj.targetChain = message.targetChain)
+      (obj.originAddress = message.originAddress);
+    message.targetChain !== undefined &&
+      (obj.targetChain = message.targetChain);
     message.targetAddress !== undefined &&
-      (obj.targetAddress = message.targetAddress)
-    message.amount !== undefined && (obj.amount = message.amount)
-    message.fee !== undefined && (obj.fee = message.fee)
-    return obj
+      (obj.targetAddress = message.targetAddress);
+    message.symbol !== undefined && (obj.symbol = message.symbol);
+    message.amount !== undefined && (obj.amount = message.amount);
+    message.fee !== undefined && (obj.fee = message.fee);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgRequestTransaction>
   ): MsgRequestTransaction {
-    const message = { ...baseMsgRequestTransaction } as MsgRequestTransaction
+    const message = { ...baseMsgRequestTransaction } as MsgRequestTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.originChain !== undefined && object.originChain !== null) {
-      message.originChain = object.originChain
+      message.originChain = object.originChain;
     } else {
-      message.originChain = ''
+      message.originChain = "";
     }
     if (object.originAddress !== undefined && object.originAddress !== null) {
-      message.originAddress = object.originAddress
+      message.originAddress = object.originAddress;
     } else {
-      message.originAddress = ''
+      message.originAddress = "";
     }
     if (object.targetChain !== undefined && object.targetChain !== null) {
-      message.targetChain = object.targetChain
+      message.targetChain = object.targetChain;
     } else {
-      message.targetChain = ''
+      message.targetChain = "";
     }
     if (object.targetAddress !== undefined && object.targetAddress !== null) {
-      message.targetAddress = object.targetAddress
+      message.targetAddress = object.targetAddress;
+    } else {
+      message.targetAddress = "";
+    }
+    if (object.symbol !== undefined && object.symbol !== null) {
+      message.symbol = object.symbol;
     } else {
-      message.targetAddress = ''
+      message.symbol = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = object.amount
+      message.amount = object.amount;
     } else {
-      message.amount = ''
+      message.amount = "";
     }
     if (object.fee !== undefined && object.fee !== null) {
-      message.fee = object.fee
+      message.fee = object.fee;
     } else {
-      message.fee = ''
+      message.fee = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgRequestTransactionResponse: object = { code: '', msg: '' }
+const baseMsgRequestTransactionResponse: object = {
+  code: "",
+  msg: "",
+  txId: "",
+};
 
 export const MsgRequestTransactionResponse = {
   encode(
     message: MsgRequestTransactionResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.code !== '') {
-      writer.uint32(10).string(message.code)
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
     }
-    if (message.msg !== '') {
-      writer.uint32(18).string(message.msg)
+    if (message.txId !== "") {
+      writer.uint32(26).string(message.txId);
     }
-    return writer
+    return writer;
   },
 
   decode(
     input: Reader | Uint8Array,
     length?: number
   ): MsgRequestTransactionResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgRequestTransactionResponse
-    } as MsgRequestTransactionResponse
+      ...baseMsgRequestTransactionResponse,
+    } as MsgRequestTransactionResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.string()
-          break
+          message.code = reader.string();
+          break;
         case 2:
-          message.msg = reader.string()
-          break
+          message.msg = reader.string();
+          break;
+        case 3:
+          message.txId = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgRequestTransactionResponse {
     const message = {
-      ...baseMsgRequestTransactionResponse
-    } as MsgRequestTransactionResponse
+      ...baseMsgRequestTransactionResponse,
+    } as MsgRequestTransactionResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = String(object.code)
+      message.code = String(object.code);
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = String(object.msg)
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    if (object.txId !== undefined && object.txId !== null) {
+      message.txId = String(object.txId);
     } else {
-      message.msg = ''
+      message.txId = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgRequestTransactionResponse): unknown {
-    const obj: any = {}
-    message.code !== undefined && (obj.code = message.code)
-    message.msg !== undefined && (obj.msg = message.msg)
-    return obj
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    message.txId !== undefined && (obj.txId = message.txId);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgRequestTransactionResponse>
   ): MsgRequestTransactionResponse {
     const message = {
-      ...baseMsgRequestTransactionResponse
-    } as MsgRequestTransactionResponse
+      ...baseMsgRequestTransactionResponse,
+    } as MsgRequestTransactionResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = object.code
+      message.code = object.code;
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = object.msg
+      message.msg = object.msg;
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
-  }
-}
+    if (object.txId !== undefined && object.txId !== null) {
+      message.txId = object.txId;
+    } else {
+      message.txId = "";
+    }
+    return message;
+  },
+};
 
 const baseMsgApproveTransaction: object = {
-  creator: '',
-  txHash: '',
-  success: '',
-  signedKey: ''
-}
+  creator: "",
+  txHash: "",
+  success: "",
+  signedKey: "",
+};
 
 export const MsgApproveTransaction = {
   encode(
     message: MsgApproveTransaction,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.txHash !== '') {
-      writer.uint32(18).string(message.txHash)
+    if (message.txHash !== "") {
+      writer.uint32(18).string(message.txHash);
     }
-    if (message.success !== '') {
-      writer.uint32(26).string(message.success)
+    if (message.success !== "") {
+      writer.uint32(26).string(message.success);
     }
-    if (message.signedKey !== '') {
-      writer.uint32(34).string(message.signedKey)
+    if (message.signedKey !== "") {
+      writer.uint32(34).string(message.signedKey);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgApproveTransaction {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgApproveTransaction } as MsgApproveTransaction
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgApproveTransaction } as MsgApproveTransaction;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.txHash = reader.string()
-          break
+          message.txHash = reader.string();
+          break;
         case 3:
-          message.success = reader.string()
-          break
+          message.success = reader.string();
+          break;
         case 4:
-          message.signedKey = reader.string()
-          break
+          message.signedKey = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgApproveTransaction {
-    const message = { ...baseMsgApproveTransaction } as MsgApproveTransaction
+    const message = { ...baseMsgApproveTransaction } as MsgApproveTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.txHash !== undefined && object.txHash !== null) {
-      message.txHash = String(object.txHash)
+      message.txHash = String(object.txHash);
     } else {
-      message.txHash = ''
+      message.txHash = "";
     }
     if (object.success !== undefined && object.success !== null) {
-      message.success = String(object.success)
+      message.success = String(object.success);
     } else {
-      message.success = ''
+      message.success = "";
     }
     if (object.signedKey !== undefined && object.signedKey !== null) {
-      message.signedKey = String(object.signedKey)
+      message.signedKey = String(object.signedKey);
     } else {
-      message.signedKey = ''
+      message.signedKey = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgApproveTransaction): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.txHash !== undefined && (obj.txHash = message.txHash)
-    message.success !== undefined && (obj.success = message.success)
-    message.signedKey !== undefined && (obj.signedKey = message.signedKey)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.txHash !== undefined && (obj.txHash = message.txHash);
+    message.success !== undefined && (obj.success = message.success);
+    message.signedKey !== undefined && (obj.signedKey = message.signedKey);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgApproveTransaction>
   ): MsgApproveTransaction {
-    const message = { ...baseMsgApproveTransaction } as MsgApproveTransaction
+    const message = { ...baseMsgApproveTransaction } as MsgApproveTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.txHash !== undefined && object.txHash !== null) {
-      message.txHash = object.txHash
+      message.txHash = object.txHash;
     } else {
-      message.txHash = ''
+      message.txHash = "";
     }
     if (object.success !== undefined && object.success !== null) {
-      message.success = object.success
+      message.success = object.success;
     } else {
-      message.success = ''
+      message.success = "";
     }
     if (object.signedKey !== undefined && object.signedKey !== null) {
-      message.signedKey = object.signedKey
+      message.signedKey = object.signedKey;
     } else {
-      message.signedKey = ''
+      message.signedKey = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgApproveTransactionResponse: object = { code: '', msg: '' }
+const baseMsgApproveTransactionResponse: object = { code: "", msg: "" };
 
 export const MsgApproveTransactionResponse = {
   encode(
     message: MsgApproveTransactionResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.code !== '') {
-      writer.uint32(10).string(message.code)
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
     }
-    if (message.msg !== '') {
-      writer.uint32(18).string(message.msg)
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
     }
-    return writer
+    return writer;
   },
 
   decode(
     input: Reader | Uint8Array,
     length?: number
   ): MsgApproveTransactionResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgApproveTransactionResponse
-    } as MsgApproveTransactionResponse
+      ...baseMsgApproveTransactionResponse,
+    } as MsgApproveTransactionResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.string()
-          break
+          message.code = reader.string();
+          break;
         case 2:
-          message.msg = reader.string()
-          break
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgApproveTransactionResponse {
     const message = {
-      ...baseMsgApproveTransactionResponse
-    } as MsgApproveTransactionResponse
+      ...baseMsgApproveTransactionResponse,
+    } as MsgApproveTransactionResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = String(object.code)
+      message.code = String(object.code);
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = String(object.msg)
+      message.msg = String(object.msg);
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgApproveTransactionResponse): unknown {
-    const obj: any = {}
-    message.code !== undefined && (obj.code = message.code)
-    message.msg !== undefined && (obj.msg = message.msg)
-    return obj
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgApproveTransactionResponse>
   ): MsgApproveTransactionResponse {
     const message = {
-      ...baseMsgApproveTransactionResponse
-    } as MsgApproveTransactionResponse
+      ...baseMsgApproveTransactionResponse,
+    } as MsgApproveTransactionResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = object.code
+      message.code = object.code;
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = object.msg
+      message.msg = object.msg;
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgFetchBalance: object = { creator: '' }
+const baseMsgFetchBalance: object = { creator: "" };
 
 export const MsgFetchBalance = {
   encode(message: MsgFetchBalance, writer: Writer = Writer.create()): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgFetchBalance {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgFetchBalance } as MsgFetchBalance
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgFetchBalance } as MsgFetchBalance;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgFetchBalance {
-    const message = { ...baseMsgFetchBalance } as MsgFetchBalance
+    const message = { ...baseMsgFetchBalance } as MsgFetchBalance;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgFetchBalance): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    return obj;
   },
 
   fromPartial(object: DeepPartial<MsgFetchBalance>): MsgFetchBalance {
-    const message = { ...baseMsgFetchBalance } as MsgFetchBalance
+    const message = { ...baseMsgFetchBalance } as MsgFetchBalance;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgFetchBalanceResponse: object = { code: '', result: '' }
+const baseMsgFetchBalanceResponse: object = { code: "", result: "" };
 
 export const MsgFetchBalanceResponse = {
   encode(
     message: MsgFetchBalanceResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.code !== '') {
-      writer.uint32(10).string(message.code)
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
     }
-    if (message.result !== '') {
-      writer.uint32(18).string(message.result)
+    if (message.result !== "") {
+      writer.uint32(18).string(message.result);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgFetchBalanceResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgFetchBalanceResponse
-    } as MsgFetchBalanceResponse
+      ...baseMsgFetchBalanceResponse,
+    } as MsgFetchBalanceResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.string()
-          break
+          message.code = reader.string();
+          break;
         case 2:
-          message.result = reader.string()
-          break
+          message.result = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgFetchBalanceResponse {
     const message = {
-      ...baseMsgFetchBalanceResponse
-    } as MsgFetchBalanceResponse
+      ...baseMsgFetchBalanceResponse,
+    } as MsgFetchBalanceResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = String(object.code)
+      message.code = String(object.code);
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.result !== undefined && object.result !== null) {
-      message.result = String(object.result)
+      message.result = String(object.result);
     } else {
-      message.result = ''
+      message.result = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgFetchBalanceResponse): unknown {
-    const obj: any = {}
-    message.code !== undefined && (obj.code = message.code)
-    message.result !== undefined && (obj.result = message.result)
-    return obj
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.result !== undefined && (obj.result = message.result);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgFetchBalanceResponse>
   ): MsgFetchBalanceResponse {
     const message = {
-      ...baseMsgFetchBalanceResponse
-    } as MsgFetchBalanceResponse
+      ...baseMsgFetchBalanceResponse,
+    } as MsgFetchBalanceResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = object.code
+      message.code = object.code;
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.result !== undefined && object.result !== null) {
-      message.result = object.result
+      message.result = object.result;
     } else {
-      message.result = ''
+      message.result = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
 const baseMsgObservationVote: object = {
-  creator: '',
-  txHash: '',
-  chainId: '',
-  from: '',
-  to: '',
-  amount: ''
-}
+  creator: "",
+  txHash: "",
+  chainId: "",
+  from: "",
+  to: "",
+  amount: "",
+};
 
 export const MsgObservationVote = {
   encode(
     message: MsgObservationVote,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.txHash !== '') {
-      writer.uint32(18).string(message.txHash)
+    if (message.txHash !== "") {
+      writer.uint32(18).string(message.txHash);
     }
-    if (message.chainId !== '') {
-      writer.uint32(26).string(message.chainId)
+    if (message.chainId !== "") {
+      writer.uint32(26).string(message.chainId);
     }
-    if (message.from !== '') {
-      writer.uint32(34).string(message.from)
+    if (message.from !== "") {
+      writer.uint32(34).string(message.from);
     }
-    if (message.to !== '') {
-      writer.uint32(42).string(message.to)
+    if (message.to !== "") {
+      writer.uint32(42).string(message.to);
     }
-    if (message.amount !== '') {
-      writer.uint32(50).string(message.amount)
+    if (message.amount !== "") {
+      writer.uint32(50).string(message.amount);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgObservationVote {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgObservationVote } as MsgObservationVote
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgObservationVote } as MsgObservationVote;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.txHash = reader.string()
-          break
+          message.txHash = reader.string();
+          break;
         case 3:
-          message.chainId = reader.string()
-          break
+          message.chainId = reader.string();
+          break;
         case 4:
-          message.from = reader.string()
-          break
+          message.from = reader.string();
+          break;
         case 5:
-          message.to = reader.string()
-          break
+          message.to = reader.string();
+          break;
         case 6:
-          message.amount = reader.string()
-          break
+          message.amount = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgObservationVote {
-    const message = { ...baseMsgObservationVote } as MsgObservationVote
+    const message = { ...baseMsgObservationVote } as MsgObservationVote;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.txHash !== undefined && object.txHash !== null) {
-      message.txHash = String(object.txHash)
+      message.txHash = String(object.txHash);
     } else {
-      message.txHash = ''
+      message.txHash = "";
     }
     if (object.chainId !== undefined && object.chainId !== null) {
-      message.chainId = String(object.chainId)
+      message.chainId = String(object.chainId);
     } else {
-      message.chainId = ''
+      message.chainId = "";
     }
     if (object.from !== undefined && object.from !== null) {
-      message.from = String(object.from)
+      message.from = String(object.from);
     } else {
-      message.from = ''
+      message.from = "";
     }
     if (object.to !== undefined && object.to !== null) {
-      message.to = String(object.to)
+      message.to = String(object.to);
     } else {
-      message.to = ''
+      message.to = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = String(object.amount)
+      message.amount = String(object.amount);
     } else {
-      message.amount = ''
+      message.amount = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgObservationVote): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.txHash !== undefined && (obj.txHash = message.txHash)
-    message.chainId !== undefined && (obj.chainId = message.chainId)
-    message.from !== undefined && (obj.from = message.from)
-    message.to !== undefined && (obj.to = message.to)
-    message.amount !== undefined && (obj.amount = message.amount)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.txHash !== undefined && (obj.txHash = message.txHash);
+    message.chainId !== undefined && (obj.chainId = message.chainId);
+    message.from !== undefined && (obj.from = message.from);
+    message.to !== undefined && (obj.to = message.to);
+    message.amount !== undefined && (obj.amount = message.amount);
+    return obj;
   },
 
   fromPartial(object: DeepPartial<MsgObservationVote>): MsgObservationVote {
-    const message = { ...baseMsgObservationVote } as MsgObservationVote
+    const message = { ...baseMsgObservationVote } as MsgObservationVote;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.txHash !== undefined && object.txHash !== null) {
-      message.txHash = object.txHash
+      message.txHash = object.txHash;
     } else {
-      message.txHash = ''
+      message.txHash = "";
     }
     if (object.chainId !== undefined && object.chainId !== null) {
-      message.chainId = object.chainId
+      message.chainId = object.chainId;
     } else {
-      message.chainId = ''
+      message.chainId = "";
     }
     if (object.from !== undefined && object.from !== null) {
-      message.from = object.from
+      message.from = object.from;
     } else {
-      message.from = ''
+      message.from = "";
     }
     if (object.to !== undefined && object.to !== null) {
-      message.to = object.to
+      message.to = object.to;
     } else {
-      message.to = ''
+      message.to = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = object.amount
+      message.amount = object.amount;
     } else {
-      message.amount = ''
+      message.amount = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgObservationVoteResponse: object = { code: '', msg: '' }
+const baseMsgObservationVoteResponse: object = { code: "", msg: "" };
 
 export const MsgObservationVoteResponse = {
   encode(
     message: MsgObservationVoteResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.code !== '') {
-      writer.uint32(10).string(message.code)
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
     }
-    if (message.msg !== '') {
-      writer.uint32(18).string(message.msg)
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
     }
-    return writer
+    return writer;
   },
 
   decode(
     input: Reader | Uint8Array,
     length?: number
   ): MsgObservationVoteResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgObservationVoteResponse
-    } as MsgObservationVoteResponse
+      ...baseMsgObservationVoteResponse,
+    } as MsgObservationVoteResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.string()
-          break
+          message.code = reader.string();
+          break;
         case 2:
-          message.msg = reader.string()
-          break
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgObservationVoteResponse {
     const message = {
-      ...baseMsgObservationVoteResponse
-    } as MsgObservationVoteResponse
+      ...baseMsgObservationVoteResponse,
+    } as MsgObservationVoteResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = String(object.code)
+      message.code = String(object.code);
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = String(object.msg)
+      message.msg = String(object.msg);
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgObservationVoteResponse): unknown {
-    const obj: any = {}
-    message.code !== undefined && (obj.code = message.code)
-    message.msg !== undefined && (obj.msg = message.msg)
-    return obj
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgObservationVoteResponse>
   ): MsgObservationVoteResponse {
     const message = {
-      ...baseMsgObservationVoteResponse
-    } as MsgObservationVoteResponse
+      ...baseMsgObservationVoteResponse,
+    } as MsgObservationVoteResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = object.code
+      message.code = object.code;
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = object.msg
+      message.msg = object.msg;
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
 const baseMsgUpdateBalance: object = {
-  creator: '',
-  chainId: '',
-  balance: '',
-  decimal: ''
-}
+  creator: "",
+  chainId: "",
+  balance: "",
+  decimal: "",
+};
 
 export const MsgUpdateBalance = {
   encode(message: MsgUpdateBalance, writer: Writer = Writer.create()): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.chainId !== '') {
-      writer.uint32(18).string(message.chainId)
+    if (message.chainId !== "") {
+      writer.uint32(18).string(message.chainId);
     }
-    if (message.balance !== '') {
-      writer.uint32(26).string(message.balance)
+    if (message.balance !== "") {
+      writer.uint32(26).string(message.balance);
     }
-    if (message.decimal !== '') {
-      writer.uint32(34).string(message.decimal)
+    if (message.decimal !== "") {
+      writer.uint32(34).string(message.decimal);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgUpdateBalance {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgUpdateBalance } as MsgUpdateBalance
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgUpdateBalance } as MsgUpdateBalance;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.chainId = reader.string()
-          break
+          message.chainId = reader.string();
+          break;
         case 3:
-          message.balance = reader.string()
-          break
+          message.balance = reader.string();
+          break;
         case 4:
-          message.decimal = reader.string()
-          break
+          message.decimal = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgUpdateBalance {
-    const message = { ...baseMsgUpdateBalance } as MsgUpdateBalance
+    const message = { ...baseMsgUpdateBalance } as MsgUpdateBalance;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.chainId !== undefined && object.chainId !== null) {
-      message.chainId = String(object.chainId)
+      message.chainId = String(object.chainId);
     } else {
-      message.chainId = ''
+      message.chainId = "";
     }
     if (object.balance !== undefined && object.balance !== null) {
-      message.balance = String(object.balance)
+      message.balance = String(object.balance);
     } else {
-      message.balance = ''
+      message.balance = "";
     }
     if (object.decimal !== undefined && object.decimal !== null) {
-      message.decimal = String(object.decimal)
+      message.decimal = String(object.decimal);
     } else {
-      message.decimal = ''
+      message.decimal = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgUpdateBalance): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.chainId !== undefined && (obj.chainId = message.chainId)
-    message.balance !== undefined && (obj.balance = message.balance)
-    message.decimal !== undefined && (obj.decimal = message.decimal)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.chainId !== undefined && (obj.chainId = message.chainId);
+    message.balance !== undefined && (obj.balance = message.balance);
+    message.decimal !== undefined && (obj.decimal = message.decimal);
+    return obj;
   },
 
   fromPartial(object: DeepPartial<MsgUpdateBalance>): MsgUpdateBalance {
-    const message = { ...baseMsgUpdateBalance } as MsgUpdateBalance
+    const message = { ...baseMsgUpdateBalance } as MsgUpdateBalance;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.chainId !== undefined && object.chainId !== null) {
-      message.chainId = object.chainId
+      message.chainId = object.chainId;
     } else {
-      message.chainId = ''
+      message.chainId = "";
     }
     if (object.balance !== undefined && object.balance !== null) {
-      message.balance = object.balance
+      message.balance = object.balance;
     } else {
-      message.balance = ''
+      message.balance = "";
     }
     if (object.decimal !== undefined && object.decimal !== null) {
-      message.decimal = object.decimal
+      message.decimal = object.decimal;
     } else {
-      message.decimal = ''
+      message.decimal = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgUpdateBalanceResponse: object = { code: '', msg: '' }
+const baseMsgUpdateBalanceResponse: object = { code: "", msg: "" };
 
 export const MsgUpdateBalanceResponse = {
   encode(
     message: MsgUpdateBalanceResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.code !== '') {
-      writer.uint32(10).string(message.code)
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
     }
-    if (message.msg !== '') {
-      writer.uint32(18).string(message.msg)
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
     }
-    return writer
+    return writer;
   },
 
   decode(
     input: Reader | Uint8Array,
     length?: number
   ): MsgUpdateBalanceResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgUpdateBalanceResponse
-    } as MsgUpdateBalanceResponse
+      ...baseMsgUpdateBalanceResponse,
+    } as MsgUpdateBalanceResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.string()
-          break
+          message.code = reader.string();
+          break;
         case 2:
-          message.msg = reader.string()
-          break
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgUpdateBalanceResponse {
     const message = {
-      ...baseMsgUpdateBalanceResponse
-    } as MsgUpdateBalanceResponse
+      ...baseMsgUpdateBalanceResponse,
+    } as MsgUpdateBalanceResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = String(object.code)
+      message.code = String(object.code);
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = String(object.msg)
+      message.msg = String(object.msg);
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgUpdateBalanceResponse): unknown {
-    const obj: any = {}
-    message.code !== undefined && (obj.code = message.code)
-    message.msg !== undefined && (obj.msg = message.msg)
-    return obj
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgUpdateBalanceResponse>
   ): MsgUpdateBalanceResponse {
     const message = {
-      ...baseMsgUpdateBalanceResponse
-    } as MsgUpdateBalanceResponse
+      ...baseMsgUpdateBalanceResponse,
+    } as MsgUpdateBalanceResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = object.code
+      message.code = object.code;
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = object.msg
+      message.msg = object.msg;
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgKeysignVote: object = { creator: '', txHash: '', pubKey: '' }
+const baseMsgKeysignVote: object = { creator: "", txHash: "", pubKey: "" };
 
 export const MsgKeysignVote = {
   encode(message: MsgKeysignVote, writer: Writer = Writer.create()): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.txHash !== '') {
-      writer.uint32(18).string(message.txHash)
+    if (message.txHash !== "") {
+      writer.uint32(18).string(message.txHash);
     }
-    if (message.pubKey !== '') {
-      writer.uint32(26).string(message.pubKey)
+    if (message.pubKey !== "") {
+      writer.uint32(26).string(message.pubKey);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgKeysignVote {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgKeysignVote } as MsgKeysignVote
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgKeysignVote } as MsgKeysignVote;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.txHash = reader.string()
-          break
+          message.txHash = reader.string();
+          break;
         case 3:
-          message.pubKey = reader.string()
-          break
+          message.pubKey = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgKeysignVote {
-    const message = { ...baseMsgKeysignVote } as MsgKeysignVote
+    const message = { ...baseMsgKeysignVote } as MsgKeysignVote;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.txHash !== undefined && object.txHash !== null) {
-      message.txHash = String(object.txHash)
+      message.txHash = String(object.txHash);
     } else {
-      message.txHash = ''
+      message.txHash = "";
     }
     if (object.pubKey !== undefined && object.pubKey !== null) {
-      message.pubKey = String(object.pubKey)
+      message.pubKey = String(object.pubKey);
     } else {
-      message.pubKey = ''
+      message.pubKey = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgKeysignVote): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.txHash !== undefined && (obj.txHash = message.txHash)
-    message.pubKey !== undefined && (obj.pubKey = message.pubKey)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.txHash !== undefined && (obj.txHash = message.txHash);
+    message.pubKey !== undefined && (obj.pubKey = message.pubKey);
+    return obj;
   },
 
   fromPartial(object: DeepPartial<MsgKeysignVote>): MsgKeysignVote {
-    const message = { ...baseMsgKeysignVote } as MsgKeysignVote
+    const message = { ...baseMsgKeysignVote } as MsgKeysignVote;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.txHash !== undefined && object.txHash !== null) {
-      message.txHash = object.txHash
+      message.txHash = object.txHash;
     } else {
-      message.txHash = ''
+      message.txHash = "";
     }
     if (object.pubKey !== undefined && object.pubKey !== null) {
-      message.pubKey = object.pubKey
+      message.pubKey = object.pubKey;
     } else {
-      message.pubKey = ''
+      message.pubKey = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgKeysignVoteResponse: object = { code: '', msg: '' }
+const baseMsgKeysignVoteResponse: object = { code: "", msg: "" };
 
 export const MsgKeysignVoteResponse = {
   encode(
     message: MsgKeysignVoteResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.code !== '') {
-      writer.uint32(10).string(message.code)
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
     }
-    if (message.msg !== '') {
-      writer.uint32(18).string(message.msg)
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgKeysignVoteResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgKeysignVoteResponse } as MsgKeysignVoteResponse
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgKeysignVoteResponse } as MsgKeysignVoteResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.code = reader.string()
-          break
+          message.code = reader.string();
+          break;
         case 2:
-          message.msg = reader.string()
-          break
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgKeysignVoteResponse {
-    const message = { ...baseMsgKeysignVoteResponse } as MsgKeysignVoteResponse
+    const message = { ...baseMsgKeysignVoteResponse } as MsgKeysignVoteResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = String(object.code)
+      message.code = String(object.code);
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = String(object.msg)
+      message.msg = String(object.msg);
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgKeysignVoteResponse): unknown {
-    const obj: any = {}
-    message.code !== undefined && (obj.code = message.code)
-    message.msg !== undefined && (obj.msg = message.msg)
-    return obj
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgKeysignVoteResponse>
   ): MsgKeysignVoteResponse {
-    const message = { ...baseMsgKeysignVoteResponse } as MsgKeysignVoteResponse
+    const message = { ...baseMsgKeysignVoteResponse } as MsgKeysignVoteResponse;
     if (object.code !== undefined && object.code !== null) {
-      message.code = object.code
+      message.code = object.code;
     } else {
-      message.code = ''
+      message.code = "";
     }
     if (object.msg !== undefined && object.msg !== null) {
-      message.msg = object.msg
+      message.msg = object.msg;
     } else {
-      message.msg = ''
+      message.msg = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgUpdateGasFee: object = { creator: '', chainId: '', fee: '' }
+const baseMsgUpdateGasFee: object = { creator: "", chainId: "", fee: "" };
 
 export const MsgUpdateGasFee = {
   encode(message: MsgUpdateGasFee, writer: Writer = Writer.create()): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.chainId !== '') {
-      writer.uint32(18).string(message.chainId)
+    if (message.chainId !== "") {
+      writer.uint32(18).string(message.chainId);
     }
-    if (message.fee !== '') {
-      writer.uint32(26).string(message.fee)
+    if (message.fee !== "") {
+      writer.uint32(26).string(message.fee);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgUpdateGasFee {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgUpdateGasFee } as MsgUpdateGasFee
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgUpdateGasFee } as MsgUpdateGasFee;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.chainId = reader.string()
-          break
+          message.chainId = reader.string();
+          break;
         case 3:
-          message.fee = reader.string()
-          break
+          message.fee = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgUpdateGasFee {
-    const message = { ...baseMsgUpdateGasFee } as MsgUpdateGasFee
+    const message = { ...baseMsgUpdateGasFee } as MsgUpdateGasFee;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.chainId !== undefined && object.chainId !== null) {
-      message.chainId = String(object.chainId)
+      message.chainId = String(object.chainId);
     } else {
-      message.chainId = ''
+      message.chainId = "";
     }
     if (object.fee !== undefined && object.fee !== null) {
-      message.fee = String(object.fee)
+      message.fee = String(object.fee);
     } else {
-      message.fee = ''
+      message.fee = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgUpdateGasFee): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.chainId !== undefined && (obj.chainId = message.chainId)
-    message.fee !== undefined && (obj.fee = message.fee)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.chainId !== undefined && (obj.chainId = message.chainId);
+    message.fee !== undefined && (obj.fee = message.fee);
+    return obj;
   },
 
   fromPartial(object: DeepPartial<MsgUpdateGasFee>): MsgUpdateGasFee {
-    const message = { ...baseMsgUpdateGasFee } as MsgUpdateGasFee
+    const message = { ...baseMsgUpdateGasFee } as MsgUpdateGasFee;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.chainId !== undefined && object.chainId !== null) {
-      message.chainId = object.chainId
+      message.chainId = object.chainId;
     } else {
-      message.chainId = ''
+      message.chainId = "";
     }
     if (object.fee !== undefined && object.fee !== null) {
-      message.fee = object.fee
+      message.fee = object.fee;
     } else {
-      message.fee = ''
+      message.fee = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgUpdateGasFeeResponse: object = {}
+const baseMsgUpdateGasFeeResponse: object = { code: "", msg: "" };
 
 export const MsgUpdateGasFeeResponse = {
-  encode(_: MsgUpdateGasFeeResponse, writer: Writer = Writer.create()): Writer {
-    return writer
+  encode(
+    message: MsgUpdateGasFeeResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgUpdateGasFeeResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgUpdateGasFeeResponse
-    } as MsgUpdateGasFeeResponse
+      ...baseMsgUpdateGasFeeResponse,
+    } as MsgUpdateGasFeeResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
-  fromJSON(_: any): MsgUpdateGasFeeResponse {
+  fromJSON(object: any): MsgUpdateGasFeeResponse {
     const message = {
-      ...baseMsgUpdateGasFeeResponse
-    } as MsgUpdateGasFeeResponse
-    return message
+      ...baseMsgUpdateGasFeeResponse,
+    } as MsgUpdateGasFeeResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
   },
 
-  toJSON(_: MsgUpdateGasFeeResponse): unknown {
-    const obj: any = {}
-    return obj
+  toJSON(message: MsgUpdateGasFeeResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
-    _: DeepPartial<MsgUpdateGasFeeResponse>
+    object: DeepPartial<MsgUpdateGasFeeResponse>
   ): MsgUpdateGasFeeResponse {
     const message = {
-      ...baseMsgUpdateGasFeeResponse
-    } as MsgUpdateGasFeeResponse
-    return message
-  }
-}
+      ...baseMsgUpdateGasFeeResponse,
+    } as MsgUpdateGasFeeResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
 
 const baseMsgProvisionTransaction: object = {
-  creator: '',
-  fromChain: '',
-  fromAddress: '',
-  symbol: '',
-  tokenAddr: '',
-  amount: '',
-  options: ''
-}
+  creator: "",
+  fromChain: "",
+  fromAddress: "",
+  symbol: "",
+  tokenAddr: "",
+  amount: "",
+  options: "",
+};
 
 export const MsgProvisionTransaction = {
   encode(
     message: MsgProvisionTransaction,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.fromChain !== '') {
-      writer.uint32(18).string(message.fromChain)
+    if (message.fromChain !== "") {
+      writer.uint32(18).string(message.fromChain);
     }
-    if (message.fromAddress !== '') {
-      writer.uint32(26).string(message.fromAddress)
+    if (message.fromAddress !== "") {
+      writer.uint32(26).string(message.fromAddress);
     }
-    if (message.symbol !== '') {
-      writer.uint32(34).string(message.symbol)
+    if (message.symbol !== "") {
+      writer.uint32(34).string(message.symbol);
     }
-    if (message.tokenAddr !== '') {
-      writer.uint32(42).string(message.tokenAddr)
+    if (message.tokenAddr !== "") {
+      writer.uint32(42).string(message.tokenAddr);
     }
-    if (message.amount !== '') {
-      writer.uint32(50).string(message.amount)
+    if (message.amount !== "") {
+      writer.uint32(50).string(message.amount);
     }
-    if (message.options !== '') {
-      writer.uint32(58).string(message.options)
+    if (message.options !== "") {
+      writer.uint32(58).string(message.options);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgProvisionTransaction {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgProvisionTransaction
-    } as MsgProvisionTransaction
+      ...baseMsgProvisionTransaction,
+    } as MsgProvisionTransaction;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.fromChain = reader.string()
-          break
+          message.fromChain = reader.string();
+          break;
         case 3:
-          message.fromAddress = reader.string()
-          break
+          message.fromAddress = reader.string();
+          break;
         case 4:
-          message.symbol = reader.string()
-          break
+          message.symbol = reader.string();
+          break;
         case 5:
-          message.tokenAddr = reader.string()
-          break
+          message.tokenAddr = reader.string();
+          break;
         case 6:
-          message.amount = reader.string()
-          break
+          message.amount = reader.string();
+          break;
         case 7:
-          message.options = reader.string()
-          break
+          message.options = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgProvisionTransaction {
     const message = {
-      ...baseMsgProvisionTransaction
-    } as MsgProvisionTransaction
+      ...baseMsgProvisionTransaction,
+    } as MsgProvisionTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.fromChain !== undefined && object.fromChain !== null) {
-      message.fromChain = String(object.fromChain)
+      message.fromChain = String(object.fromChain);
     } else {
-      message.fromChain = ''
+      message.fromChain = "";
     }
     if (object.fromAddress !== undefined && object.fromAddress !== null) {
-      message.fromAddress = String(object.fromAddress)
+      message.fromAddress = String(object.fromAddress);
     } else {
-      message.fromAddress = ''
+      message.fromAddress = "";
     }
     if (object.symbol !== undefined && object.symbol !== null) {
-      message.symbol = String(object.symbol)
+      message.symbol = String(object.symbol);
     } else {
-      message.symbol = ''
+      message.symbol = "";
     }
     if (object.tokenAddr !== undefined && object.tokenAddr !== null) {
-      message.tokenAddr = String(object.tokenAddr)
+      message.tokenAddr = String(object.tokenAddr);
     } else {
-      message.tokenAddr = ''
+      message.tokenAddr = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = String(object.amount)
+      message.amount = String(object.amount);
     } else {
-      message.amount = ''
+      message.amount = "";
     }
     if (object.options !== undefined && object.options !== null) {
-      message.options = String(object.options)
+      message.options = String(object.options);
     } else {
-      message.options = ''
+      message.options = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgProvisionTransaction): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.fromChain !== undefined && (obj.fromChain = message.fromChain)
-    message.fromAddress !== undefined && (obj.fromAddress = message.fromAddress)
-    message.symbol !== undefined && (obj.symbol = message.symbol)
-    message.tokenAddr !== undefined && (obj.tokenAddr = message.tokenAddr)
-    message.amount !== undefined && (obj.amount = message.amount)
-    message.options !== undefined && (obj.options = message.options)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.fromChain !== undefined && (obj.fromChain = message.fromChain);
+    message.fromAddress !== undefined &&
+      (obj.fromAddress = message.fromAddress);
+    message.symbol !== undefined && (obj.symbol = message.symbol);
+    message.tokenAddr !== undefined && (obj.tokenAddr = message.tokenAddr);
+    message.amount !== undefined && (obj.amount = message.amount);
+    message.options !== undefined && (obj.options = message.options);
+    return obj;
   },
 
   fromPartial(
     object: DeepPartial<MsgProvisionTransaction>
   ): MsgProvisionTransaction {
     const message = {
-      ...baseMsgProvisionTransaction
-    } as MsgProvisionTransaction
+      ...baseMsgProvisionTransaction,
+    } as MsgProvisionTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.fromChain !== undefined && object.fromChain !== null) {
-      message.fromChain = object.fromChain
+      message.fromChain = object.fromChain;
     } else {
-      message.fromChain = ''
+      message.fromChain = "";
     }
     if (object.fromAddress !== undefined && object.fromAddress !== null) {
-      message.fromAddress = object.fromAddress
+      message.fromAddress = object.fromAddress;
     } else {
-      message.fromAddress = ''
+      message.fromAddress = "";
     }
     if (object.symbol !== undefined && object.symbol !== null) {
-      message.symbol = object.symbol
+      message.symbol = object.symbol;
     } else {
-      message.symbol = ''
+      message.symbol = "";
     }
     if (object.tokenAddr !== undefined && object.tokenAddr !== null) {
-      message.tokenAddr = object.tokenAddr
+      message.tokenAddr = object.tokenAddr;
     } else {
-      message.tokenAddr = ''
+      message.tokenAddr = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = object.amount
+      message.amount = object.amount;
     } else {
-      message.amount = ''
+      message.amount = "";
     }
     if (object.options !== undefined && object.options !== null) {
-      message.options = object.options
+      message.options = object.options;
     } else {
-      message.options = ''
+      message.options = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgProvisionTransactionResponse: object = {}
+const baseMsgProvisionTransactionResponse: object = { code: "", msg: "" };
 
 export const MsgProvisionTransactionResponse = {
   encode(
-    _: MsgProvisionTransactionResponse,
+    message: MsgProvisionTransactionResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    return writer
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
   },
 
   decode(
     input: Reader | Uint8Array,
     length?: number
   ): MsgProvisionTransactionResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgProvisionTransactionResponse
-    } as MsgProvisionTransactionResponse
+      ...baseMsgProvisionTransactionResponse,
+    } as MsgProvisionTransactionResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
-  fromJSON(_: any): MsgProvisionTransactionResponse {
+  fromJSON(object: any): MsgProvisionTransactionResponse {
     const message = {
-      ...baseMsgProvisionTransactionResponse
-    } as MsgProvisionTransactionResponse
-    return message
+      ...baseMsgProvisionTransactionResponse,
+    } as MsgProvisionTransactionResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
   },
 
-  toJSON(_: MsgProvisionTransactionResponse): unknown {
-    const obj: any = {}
-    return obj
+  toJSON(message: MsgProvisionTransactionResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
-    _: DeepPartial<MsgProvisionTransactionResponse>
+    object: DeepPartial<MsgProvisionTransactionResponse>
   ): MsgProvisionTransactionResponse {
     const message = {
-      ...baseMsgProvisionTransactionResponse
-    } as MsgProvisionTransactionResponse
-    return message
-  }
-}
+      ...baseMsgProvisionTransactionResponse,
+    } as MsgProvisionTransactionResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
 
 const baseMsgDrainTransaction: object = {
-  creator: '',
-  fromChain: '',
-  toChain: '',
-  toAddress: '',
-  nftAddr: '',
-  amount: '',
-  options: ''
-}
+  creator: "",
+  fromChain: "",
+  toChain: "",
+  toAddress: "",
+  nftAddr: "",
+  amount: "",
+  options: "",
+};
 
 export const MsgDrainTransaction = {
   encode(
     message: MsgDrainTransaction,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.fromChain !== '') {
-      writer.uint32(18).string(message.fromChain)
+    if (message.fromChain !== "") {
+      writer.uint32(18).string(message.fromChain);
     }
-    if (message.toChain !== '') {
-      writer.uint32(26).string(message.toChain)
+    if (message.toChain !== "") {
+      writer.uint32(26).string(message.toChain);
     }
-    if (message.toAddress !== '') {
-      writer.uint32(34).string(message.toAddress)
+    if (message.toAddress !== "") {
+      writer.uint32(34).string(message.toAddress);
     }
-    if (message.nftAddr !== '') {
-      writer.uint32(42).string(message.nftAddr)
+    if (message.nftAddr !== "") {
+      writer.uint32(42).string(message.nftAddr);
     }
-    if (message.amount !== '') {
-      writer.uint32(50).string(message.amount)
+    if (message.amount !== "") {
+      writer.uint32(50).string(message.amount);
     }
-    if (message.options !== '') {
-      writer.uint32(58).string(message.options)
+    if (message.options !== "") {
+      writer.uint32(58).string(message.options);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgDrainTransaction {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgDrainTransaction } as MsgDrainTransaction
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgDrainTransaction } as MsgDrainTransaction;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.fromChain = reader.string()
-          break
+          message.fromChain = reader.string();
+          break;
         case 3:
-          message.toChain = reader.string()
-          break
+          message.toChain = reader.string();
+          break;
         case 4:
-          message.toAddress = reader.string()
-          break
+          message.toAddress = reader.string();
+          break;
         case 5:
-          message.nftAddr = reader.string()
-          break
+          message.nftAddr = reader.string();
+          break;
         case 6:
-          message.amount = reader.string()
-          break
+          message.amount = reader.string();
+          break;
         case 7:
-          message.options = reader.string()
-          break
+          message.options = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgDrainTransaction {
-    const message = { ...baseMsgDrainTransaction } as MsgDrainTransaction
+    const message = { ...baseMsgDrainTransaction } as MsgDrainTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.fromChain !== undefined && object.fromChain !== null) {
-      message.fromChain = String(object.fromChain)
+      message.fromChain = String(object.fromChain);
     } else {
-      message.fromChain = ''
+      message.fromChain = "";
     }
     if (object.toChain !== undefined && object.toChain !== null) {
-      message.toChain = String(object.toChain)
+      message.toChain = String(object.toChain);
     } else {
-      message.toChain = ''
+      message.toChain = "";
     }
     if (object.toAddress !== undefined && object.toAddress !== null) {
-      message.toAddress = String(object.toAddress)
+      message.toAddress = String(object.toAddress);
     } else {
-      message.toAddress = ''
+      message.toAddress = "";
     }
     if (object.nftAddr !== undefined && object.nftAddr !== null) {
-      message.nftAddr = String(object.nftAddr)
+      message.nftAddr = String(object.nftAddr);
     } else {
-      message.nftAddr = ''
+      message.nftAddr = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = String(object.amount)
+      message.amount = String(object.amount);
     } else {
-      message.amount = ''
+      message.amount = "";
     }
     if (object.options !== undefined && object.options !== null) {
-      message.options = String(object.options)
+      message.options = String(object.options);
     } else {
-      message.options = ''
+      message.options = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgDrainTransaction): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
-    message.fromChain !== undefined && (obj.fromChain = message.fromChain)
-    message.toChain !== undefined && (obj.toChain = message.toChain)
-    message.toAddress !== undefined && (obj.toAddress = message.toAddress)
-    message.nftAddr !== undefined && (obj.nftAddr = message.nftAddr)
-    message.amount !== undefined && (obj.amount = message.amount)
-    message.options !== undefined && (obj.options = message.options)
-    return obj
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.fromChain !== undefined && (obj.fromChain = message.fromChain);
+    message.toChain !== undefined && (obj.toChain = message.toChain);
+    message.toAddress !== undefined && (obj.toAddress = message.toAddress);
+    message.nftAddr !== undefined && (obj.nftAddr = message.nftAddr);
+    message.amount !== undefined && (obj.amount = message.amount);
+    message.options !== undefined && (obj.options = message.options);
+    return obj;
   },
 
   fromPartial(object: DeepPartial<MsgDrainTransaction>): MsgDrainTransaction {
-    const message = { ...baseMsgDrainTransaction } as MsgDrainTransaction
+    const message = { ...baseMsgDrainTransaction } as MsgDrainTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.fromChain !== undefined && object.fromChain !== null) {
-      message.fromChain = object.fromChain
+      message.fromChain = object.fromChain;
     } else {
-      message.fromChain = ''
+      message.fromChain = "";
     }
     if (object.toChain !== undefined && object.toChain !== null) {
-      message.toChain = object.toChain
+      message.toChain = object.toChain;
     } else {
-      message.toChain = ''
+      message.toChain = "";
     }
     if (object.toAddress !== undefined && object.toAddress !== null) {
-      message.toAddress = object.toAddress
+      message.toAddress = object.toAddress;
     } else {
-      message.toAddress = ''
+      message.toAddress = "";
     }
     if (object.nftAddr !== undefined && object.nftAddr !== null) {
-      message.nftAddr = object.nftAddr
+      message.nftAddr = object.nftAddr;
     } else {
-      message.nftAddr = ''
+      message.nftAddr = "";
     }
     if (object.amount !== undefined && object.amount !== null) {
-      message.amount = object.amount
+      message.amount = object.amount;
     } else {
-      message.amount = ''
+      message.amount = "";
     }
     if (object.options !== undefined && object.options !== null) {
-      message.options = object.options
+      message.options = object.options;
     } else {
-      message.options = ''
+      message.options = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgDrainTransactionResponse: object = {}
+const baseMsgDrainTransactionResponse: object = { code: "", msg: "" };
 
 export const MsgDrainTransactionResponse = {
   encode(
-    _: MsgDrainTransactionResponse,
+    message: MsgDrainTransactionResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    return writer
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
   },
 
   decode(
     input: Reader | Uint8Array,
     length?: number
   ): MsgDrainTransactionResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgDrainTransactionResponse
-    } as MsgDrainTransactionResponse
+      ...baseMsgDrainTransactionResponse,
+    } as MsgDrainTransactionResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
-  fromJSON(_: any): MsgDrainTransactionResponse {
+  fromJSON(object: any): MsgDrainTransactionResponse {
     const message = {
-      ...baseMsgDrainTransactionResponse
-    } as MsgDrainTransactionResponse
-    return message
+      ...baseMsgDrainTransactionResponse,
+    } as MsgDrainTransactionResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
   },
 
-  toJSON(_: MsgDrainTransactionResponse): unknown {
-    const obj: any = {}
-    return obj
+  toJSON(message: MsgDrainTransactionResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
-    _: DeepPartial<MsgDrainTransactionResponse>
+    object: DeepPartial<MsgDrainTransactionResponse>
   ): MsgDrainTransactionResponse {
     const message = {
-      ...baseMsgDrainTransactionResponse
-    } as MsgDrainTransactionResponse
-    return message
-  }
-}
+      ...baseMsgDrainTransactionResponse,
+    } as MsgDrainTransactionResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
 
-const baseMsgCancelTransaction: object = { creator: '', transactionId: '' }
+const baseMsgCancelTransaction: object = { creator: "", transactionId: "" };
 
 export const MsgCancelTransaction = {
   encode(
     message: MsgCancelTransaction,
     writer: Writer = Writer.create()
   ): Writer {
-    if (message.creator !== '') {
-      writer.uint32(10).string(message.creator)
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
     }
-    if (message.transactionId !== '') {
-      writer.uint32(18).string(message.transactionId)
+    if (message.transactionId !== "") {
+      writer.uint32(18).string(message.transactionId);
     }
-    return writer
+    return writer;
   },
 
   decode(input: Reader | Uint8Array, length?: number): MsgCancelTransaction {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = { ...baseMsgCancelTransaction } as MsgCancelTransaction
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgCancelTransaction } as MsgCancelTransaction;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.creator = reader.string()
-          break
+          message.creator = reader.string();
+          break;
         case 2:
-          message.transactionId = reader.string()
-          break
+          message.transactionId = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   fromJSON(object: any): MsgCancelTransaction {
-    const message = { ...baseMsgCancelTransaction } as MsgCancelTransaction
+    const message = { ...baseMsgCancelTransaction } as MsgCancelTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = String(object.creator)
+      message.creator = String(object.creator);
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.transactionId !== undefined && object.transactionId !== null) {
-      message.transactionId = String(object.transactionId)
+      message.transactionId = String(object.transactionId);
     } else {
-      message.transactionId = ''
+      message.transactionId = "";
     }
-    return message
+    return message;
   },
 
   toJSON(message: MsgCancelTransaction): unknown {
-    const obj: any = {}
-    message.creator !== undefined && (obj.creator = message.creator)
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
     message.transactionId !== undefined &&
-      (obj.transactionId = message.transactionId)
-    return obj
+      (obj.transactionId = message.transactionId);
+    return obj;
   },
 
   fromPartial(object: DeepPartial<MsgCancelTransaction>): MsgCancelTransaction {
-    const message = { ...baseMsgCancelTransaction } as MsgCancelTransaction
+    const message = { ...baseMsgCancelTransaction } as MsgCancelTransaction;
     if (object.creator !== undefined && object.creator !== null) {
-      message.creator = object.creator
+      message.creator = object.creator;
     } else {
-      message.creator = ''
+      message.creator = "";
     }
     if (object.transactionId !== undefined && object.transactionId !== null) {
-      message.transactionId = object.transactionId
+      message.transactionId = object.transactionId;
     } else {
-      message.transactionId = ''
+      message.transactionId = "";
     }
-    return message
-  }
-}
+    return message;
+  },
+};
 
-const baseMsgCancelTransactionResponse: object = {}
+const baseMsgCancelTransactionResponse: object = { code: "", msg: "" };
 
 export const MsgCancelTransactionResponse = {
   encode(
-    _: MsgCancelTransactionResponse,
+    message: MsgCancelTransactionResponse,
     writer: Writer = Writer.create()
   ): Writer {
-    return writer
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
   },
 
   decode(
     input: Reader | Uint8Array,
     length?: number
   ): MsgCancelTransactionResponse {
-    const reader = input instanceof Uint8Array ? new Reader(input) : input
-    let end = length === undefined ? reader.len : reader.pos + length
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
     const message = {
-      ...baseMsgCancelTransactionResponse
-    } as MsgCancelTransactionResponse
+      ...baseMsgCancelTransactionResponse,
+    } as MsgCancelTransactionResponse;
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
-  fromJSON(_: any): MsgCancelTransactionResponse {
+  fromJSON(object: any): MsgCancelTransactionResponse {
     const message = {
-      ...baseMsgCancelTransactionResponse
-    } as MsgCancelTransactionResponse
-    return message
+      ...baseMsgCancelTransactionResponse,
+    } as MsgCancelTransactionResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
   },
 
-  toJSON(_: MsgCancelTransactionResponse): unknown {
-    const obj: any = {}
-    return obj
+  toJSON(message: MsgCancelTransactionResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
   },
 
   fromPartial(
-    _: DeepPartial<MsgCancelTransactionResponse>
+    object: DeepPartial<MsgCancelTransactionResponse>
   ): MsgCancelTransactionResponse {
     const message = {
-      ...baseMsgCancelTransactionResponse
-    } as MsgCancelTransactionResponse
-    return message
-  }
-}
+      ...baseMsgCancelTransactionResponse,
+    } as MsgCancelTransactionResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
 
-/** Msg defines the Msg service. */
-export interface Msg {
-  RequestTransaction(
-    request: MsgRequestTransaction
-  ): Promise<MsgRequestTransactionResponse>
-  ApproveTransaction(
-    request: MsgApproveTransaction
-  ): Promise<MsgApproveTransactionResponse>
-  FetchBalance(request: MsgFetchBalance): Promise<MsgFetchBalanceResponse>
-  ObservationVote(
-    request: MsgObservationVote
-  ): Promise<MsgObservationVoteResponse>
-  UpdateBalance(request: MsgUpdateBalance): Promise<MsgUpdateBalanceResponse>
-  KeysignVote(request: MsgKeysignVote): Promise<MsgKeysignVoteResponse>
-  UpdateGasFee(request: MsgUpdateGasFee): Promise<MsgUpdateGasFeeResponse>
-  ProvisionTransaction(
-    request: MsgProvisionTransaction
-  ): Promise<MsgProvisionTransactionResponse>
-  DrainTransaction(
-    request: MsgDrainTransaction
-  ): Promise<MsgDrainTransactionResponse>
-  /** this line is used by starport scaffolding # proto/tx/rpc */
-  CancelTransaction(
-    request: MsgCancelTransaction
-  ): Promise<MsgCancelTransactionResponse>
-}
+const baseMsgAddWhitelisted: object = { creator: "", address: "" };
 
-export class MsgClientImpl implements Msg {
-  private readonly rpc: Rpc
-  constructor(rpc: Rpc) {
-    this.rpc = rpc
-  }
-  RequestTransaction(
-    request: MsgRequestTransaction
-  ): Promise<MsgRequestTransactionResponse> {
-    const data = MsgRequestTransaction.encode(request).finish()
-    const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'RequestTransaction',
-      data
-    )
-    return promise.then((data) =>
-      MsgRequestTransactionResponse.decode(new Reader(data))
-    )
-  }
+export const MsgAddWhitelisted = {
+  encode(message: MsgAddWhitelisted, writer: Writer = Writer.create()): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.address !== "") {
+      writer.uint32(18).string(message.address);
+    }
+    return writer;
+  },
 
-  ApproveTransaction(
-    request: MsgApproveTransaction
-  ): Promise<MsgApproveTransactionResponse> {
-    const data = MsgApproveTransaction.encode(request).finish()
-    const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'ApproveTransaction',
-      data
-    )
-    return promise.then((data) =>
-      MsgApproveTransactionResponse.decode(new Reader(data))
-    )
-  }
+  decode(input: Reader | Uint8Array, length?: number): MsgAddWhitelisted {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgAddWhitelisted } as MsgAddWhitelisted;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
 
-  FetchBalance(request: MsgFetchBalance): Promise<MsgFetchBalanceResponse> {
-    const data = MsgFetchBalance.encode(request).finish()
-    const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'FetchBalance',
-      data
-    )
-    return promise.then((data) =>
-      MsgFetchBalanceResponse.decode(new Reader(data))
-    )
-  }
+  fromJSON(object: any): MsgAddWhitelisted {
+    const message = { ...baseMsgAddWhitelisted } as MsgAddWhitelisted;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    if (object.address !== undefined && object.address !== null) {
+      message.address = String(object.address);
+    } else {
+      message.address = "";
+    }
+    return message;
+  },
 
-  ObservationVote(
-    request: MsgObservationVote
-  ): Promise<MsgObservationVoteResponse> {
-    const data = MsgObservationVote.encode(request).finish()
-    const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'ObservationVote',
-      data
-    )
-    return promise.then((data) =>
-      MsgObservationVoteResponse.decode(new Reader(data))
-    )
-  }
+  toJSON(message: MsgAddWhitelisted): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.address !== undefined && (obj.address = message.address);
+    return obj;
+  },
 
-  UpdateBalance(request: MsgUpdateBalance): Promise<MsgUpdateBalanceResponse> {
-    const data = MsgUpdateBalance.encode(request).finish()
-    const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'UpdateBalance',
-      data
-    )
-    return promise.then((data) =>
-      MsgUpdateBalanceResponse.decode(new Reader(data))
-    )
-  }
+  fromPartial(object: DeepPartial<MsgAddWhitelisted>): MsgAddWhitelisted {
+    const message = { ...baseMsgAddWhitelisted } as MsgAddWhitelisted;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    } else {
+      message.address = "";
+    }
+    return message;
+  },
+};
 
-  KeysignVote(request: MsgKeysignVote): Promise<MsgKeysignVoteResponse> {
-    const data = MsgKeysignVote.encode(request).finish()
-    const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'KeysignVote',
-      data
-    )
+const baseMsgAddWhitelistedResponse: object = { code: "", msg: "" };
+
+export const MsgAddWhitelistedResponse = {
+  encode(
+    message: MsgAddWhitelistedResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
+  },
+
+  decode(
+    input: Reader | Uint8Array,
+    length?: number
+  ): MsgAddWhitelistedResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = {
+      ...baseMsgAddWhitelistedResponse,
+    } as MsgAddWhitelistedResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgAddWhitelistedResponse {
+    const message = {
+      ...baseMsgAddWhitelistedResponse,
+    } as MsgAddWhitelistedResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgAddWhitelistedResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<MsgAddWhitelistedResponse>
+  ): MsgAddWhitelistedResponse {
+    const message = {
+      ...baseMsgAddWhitelistedResponse,
+    } as MsgAddWhitelistedResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgSetAdmin: object = { creator: "" };
+
+export const MsgSetAdmin = {
+  encode(message: MsgSetAdmin, writer: Writer = Writer.create()): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgSetAdmin {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgSetAdmin } as MsgSetAdmin;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSetAdmin {
+    const message = { ...baseMsgSetAdmin } as MsgSetAdmin;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgSetAdmin): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgSetAdmin>): MsgSetAdmin {
+    const message = { ...baseMsgSetAdmin } as MsgSetAdmin;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgSetAdminResponse: object = { code: "", msg: "" };
+
+export const MsgSetAdminResponse = {
+  encode(
+    message: MsgSetAdminResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgSetAdminResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgSetAdminResponse } as MsgSetAdminResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSetAdminResponse {
+    const message = { ...baseMsgSetAdminResponse } as MsgSetAdminResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgSetAdminResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgSetAdminResponse>): MsgSetAdminResponse {
+    const message = { ...baseMsgSetAdminResponse } as MsgSetAdminResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgAddPubkey: object = { creator: "", pubkey: "" };
+
+export const MsgAddPubkey = {
+  encode(message: MsgAddPubkey, writer: Writer = Writer.create()): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.pubkey !== "") {
+      writer.uint32(18).string(message.pubkey);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgAddPubkey {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgAddPubkey } as MsgAddPubkey;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.pubkey = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgAddPubkey {
+    const message = { ...baseMsgAddPubkey } as MsgAddPubkey;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    if (object.pubkey !== undefined && object.pubkey !== null) {
+      message.pubkey = String(object.pubkey);
+    } else {
+      message.pubkey = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgAddPubkey): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.pubkey !== undefined && (obj.pubkey = message.pubkey);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgAddPubkey>): MsgAddPubkey {
+    const message = { ...baseMsgAddPubkey } as MsgAddPubkey;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    if (object.pubkey !== undefined && object.pubkey !== null) {
+      message.pubkey = object.pubkey;
+    } else {
+      message.pubkey = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgAddPubkeyResponse: object = { code: "", msg: "" };
+
+export const MsgAddPubkeyResponse = {
+  encode(
+    message: MsgAddPubkeyResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgAddPubkeyResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgAddPubkeyResponse } as MsgAddPubkeyResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgAddPubkeyResponse {
+    const message = { ...baseMsgAddPubkeyResponse } as MsgAddPubkeyResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgAddPubkeyResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgAddPubkeyResponse>): MsgAddPubkeyResponse {
+    const message = { ...baseMsgAddPubkeyResponse } as MsgAddPubkeyResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgUpdateTssPubkey: object = {
+  creator: "",
+  tssPubkey: "",
+  ecdsa: "",
+  ebdsa: "",
+  reserved: "",
+};
+
+export const MsgUpdateTssPubkey = {
+  encode(
+    message: MsgUpdateTssPubkey,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.tssPubkey !== "") {
+      writer.uint32(18).string(message.tssPubkey);
+    }
+    if (message.ecdsa !== "") {
+      writer.uint32(26).string(message.ecdsa);
+    }
+    if (message.ebdsa !== "") {
+      writer.uint32(34).string(message.ebdsa);
+    }
+    if (message.reserved !== "") {
+      writer.uint32(42).string(message.reserved);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgUpdateTssPubkey {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgUpdateTssPubkey } as MsgUpdateTssPubkey;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.tssPubkey = reader.string();
+          break;
+        case 3:
+          message.ecdsa = reader.string();
+          break;
+        case 4:
+          message.ebdsa = reader.string();
+          break;
+        case 5:
+          message.reserved = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateTssPubkey {
+    const message = { ...baseMsgUpdateTssPubkey } as MsgUpdateTssPubkey;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    if (object.tssPubkey !== undefined && object.tssPubkey !== null) {
+      message.tssPubkey = String(object.tssPubkey);
+    } else {
+      message.tssPubkey = "";
+    }
+    if (object.ecdsa !== undefined && object.ecdsa !== null) {
+      message.ecdsa = String(object.ecdsa);
+    } else {
+      message.ecdsa = "";
+    }
+    if (object.ebdsa !== undefined && object.ebdsa !== null) {
+      message.ebdsa = String(object.ebdsa);
+    } else {
+      message.ebdsa = "";
+    }
+    if (object.reserved !== undefined && object.reserved !== null) {
+      message.reserved = String(object.reserved);
+    } else {
+      message.reserved = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgUpdateTssPubkey): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.tssPubkey !== undefined && (obj.tssPubkey = message.tssPubkey);
+    message.ecdsa !== undefined && (obj.ecdsa = message.ecdsa);
+    message.ebdsa !== undefined && (obj.ebdsa = message.ebdsa);
+    message.reserved !== undefined && (obj.reserved = message.reserved);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgUpdateTssPubkey>): MsgUpdateTssPubkey {
+    const message = { ...baseMsgUpdateTssPubkey } as MsgUpdateTssPubkey;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    if (object.tssPubkey !== undefined && object.tssPubkey !== null) {
+      message.tssPubkey = object.tssPubkey;
+    } else {
+      message.tssPubkey = "";
+    }
+    if (object.ecdsa !== undefined && object.ecdsa !== null) {
+      message.ecdsa = object.ecdsa;
+    } else {
+      message.ecdsa = "";
+    }
+    if (object.ebdsa !== undefined && object.ebdsa !== null) {
+      message.ebdsa = object.ebdsa;
+    } else {
+      message.ebdsa = "";
+    }
+    if (object.reserved !== undefined && object.reserved !== null) {
+      message.reserved = object.reserved;
+    } else {
+      message.reserved = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgUpdateTssPubkeyResponse: object = { code: "", msg: "" };
+
+export const MsgUpdateTssPubkeyResponse = {
+  encode(
+    message: MsgUpdateTssPubkeyResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
+  },
+
+  decode(
+    input: Reader | Uint8Array,
+    length?: number
+  ): MsgUpdateTssPubkeyResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = {
+      ...baseMsgUpdateTssPubkeyResponse,
+    } as MsgUpdateTssPubkeyResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateTssPubkeyResponse {
+    const message = {
+      ...baseMsgUpdateTssPubkeyResponse,
+    } as MsgUpdateTssPubkeyResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgUpdateTssPubkeyResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<MsgUpdateTssPubkeyResponse>
+  ): MsgUpdateTssPubkeyResponse {
+    const message = {
+      ...baseMsgUpdateTssPubkeyResponse,
+    } as MsgUpdateTssPubkeyResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgRemoveWhitelisted: object = { creator: "", address: "" };
+
+export const MsgRemoveWhitelisted = {
+  encode(
+    message: MsgRemoveWhitelisted,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.address !== "") {
+      writer.uint32(18).string(message.address);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgRemoveWhitelisted {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgRemoveWhitelisted } as MsgRemoveWhitelisted;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgRemoveWhitelisted {
+    const message = { ...baseMsgRemoveWhitelisted } as MsgRemoveWhitelisted;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    if (object.address !== undefined && object.address !== null) {
+      message.address = String(object.address);
+    } else {
+      message.address = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgRemoveWhitelisted): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.address !== undefined && (obj.address = message.address);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgRemoveWhitelisted>): MsgRemoveWhitelisted {
+    const message = { ...baseMsgRemoveWhitelisted } as MsgRemoveWhitelisted;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    } else {
+      message.address = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgRemoveWhitelistedResponse: object = { code: "", msg: "" };
+
+export const MsgRemoveWhitelistedResponse = {
+  encode(
+    message: MsgRemoveWhitelistedResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
+  },
+
+  decode(
+    input: Reader | Uint8Array,
+    length?: number
+  ): MsgRemoveWhitelistedResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = {
+      ...baseMsgRemoveWhitelistedResponse,
+    } as MsgRemoveWhitelistedResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgRemoveWhitelistedResponse {
+    const message = {
+      ...baseMsgRemoveWhitelistedResponse,
+    } as MsgRemoveWhitelistedResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgRemoveWhitelistedResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<MsgRemoveWhitelistedResponse>
+  ): MsgRemoveWhitelistedResponse {
+    const message = {
+      ...baseMsgRemoveWhitelistedResponse,
+    } as MsgRemoveWhitelistedResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgClearTssInfo: object = { creator: "" };
+
+export const MsgClearTssInfo = {
+  encode(message: MsgClearTssInfo, writer: Writer = Writer.create()): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgClearTssInfo {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgClearTssInfo } as MsgClearTssInfo;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgClearTssInfo {
+    const message = { ...baseMsgClearTssInfo } as MsgClearTssInfo;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgClearTssInfo): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgClearTssInfo>): MsgClearTssInfo {
+    const message = { ...baseMsgClearTssInfo } as MsgClearTssInfo;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgClearTssInfoResponse: object = { code: "", msg: "" };
+
+export const MsgClearTssInfoResponse = {
+  encode(
+    message: MsgClearTssInfoResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgClearTssInfoResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = {
+      ...baseMsgClearTssInfoResponse,
+    } as MsgClearTssInfoResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.code = reader.string();
+          break;
+        case 2:
+          message.msg = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgClearTssInfoResponse {
+    const message = {
+      ...baseMsgClearTssInfoResponse,
+    } as MsgClearTssInfoResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = String(object.code);
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = String(object.msg);
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgClearTssInfoResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<MsgClearTssInfoResponse>
+  ): MsgClearTssInfoResponse {
+    const message = {
+      ...baseMsgClearTssInfoResponse,
+    } as MsgClearTssInfoResponse;
+    if (object.code !== undefined && object.code !== null) {
+      message.code = object.code;
+    } else {
+      message.code = "";
+    }
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    } else {
+      message.msg = "";
+    }
+    return message;
+  },
+};
+
+/** Msg defines the Msg service. */
+export interface Msg {
+  RequestTransaction(
+    request: MsgRequestTransaction
+  ): Promise<MsgRequestTransactionResponse>;
+  ApproveTransaction(
+    request: MsgApproveTransaction
+  ): Promise<MsgApproveTransactionResponse>;
+  FetchBalance(request: MsgFetchBalance): Promise<MsgFetchBalanceResponse>;
+  ObservationVote(
+    request: MsgObservationVote
+  ): Promise<MsgObservationVoteResponse>;
+  UpdateBalance(request: MsgUpdateBalance): Promise<MsgUpdateBalanceResponse>;
+  KeysignVote(request: MsgKeysignVote): Promise<MsgKeysignVoteResponse>;
+  UpdateGasFee(request: MsgUpdateGasFee): Promise<MsgUpdateGasFeeResponse>;
+  ProvisionTransaction(
+    request: MsgProvisionTransaction
+  ): Promise<MsgProvisionTransactionResponse>;
+  DrainTransaction(
+    request: MsgDrainTransaction
+  ): Promise<MsgDrainTransactionResponse>;
+  CancelTransaction(
+    request: MsgCancelTransaction
+  ): Promise<MsgCancelTransactionResponse>;
+  AddWhitelisted(
+    request: MsgAddWhitelisted
+  ): Promise<MsgAddWhitelistedResponse>;
+  SetAdmin(request: MsgSetAdmin): Promise<MsgSetAdminResponse>;
+  AddPubkey(request: MsgAddPubkey): Promise<MsgAddPubkeyResponse>;
+  UpdateTssPubkey(
+    request: MsgUpdateTssPubkey
+  ): Promise<MsgUpdateTssPubkeyResponse>;
+  RemoveWhitelisted(
+    request: MsgRemoveWhitelisted
+  ): Promise<MsgRemoveWhitelistedResponse>;
+  /** this line is used by starport scaffolding # proto/tx/rpc */
+  ClearTssInfo(request: MsgClearTssInfo): Promise<MsgClearTssInfoResponse>;
+}
+
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+  }
+  RequestTransaction(
+    request: MsgRequestTransaction
+  ): Promise<MsgRequestTransactionResponse> {
+    const data = MsgRequestTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "RequestTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgRequestTransactionResponse.decode(new Reader(data))
+    );
+  }
+
+  ApproveTransaction(
+    request: MsgApproveTransaction
+  ): Promise<MsgApproveTransactionResponse> {
+    const data = MsgApproveTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "ApproveTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgApproveTransactionResponse.decode(new Reader(data))
+    );
+  }
+
+  FetchBalance(request: MsgFetchBalance): Promise<MsgFetchBalanceResponse> {
+    const data = MsgFetchBalance.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "FetchBalance",
+      data
+    );
+    return promise.then((data) =>
+      MsgFetchBalanceResponse.decode(new Reader(data))
+    );
+  }
+
+  ObservationVote(
+    request: MsgObservationVote
+  ): Promise<MsgObservationVoteResponse> {
+    const data = MsgObservationVote.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "ObservationVote",
+      data
+    );
+    return promise.then((data) =>
+      MsgObservationVoteResponse.decode(new Reader(data))
+    );
+  }
+
+  UpdateBalance(request: MsgUpdateBalance): Promise<MsgUpdateBalanceResponse> {
+    const data = MsgUpdateBalance.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "UpdateBalance",
+      data
+    );
+    return promise.then((data) =>
+      MsgUpdateBalanceResponse.decode(new Reader(data))
+    );
+  }
+
+  KeysignVote(request: MsgKeysignVote): Promise<MsgKeysignVoteResponse> {
+    const data = MsgKeysignVote.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "KeysignVote",
+      data
+    );
     return promise.then((data) =>
       MsgKeysignVoteResponse.decode(new Reader(data))
-    )
+    );
   }
 
   UpdateGasFee(request: MsgUpdateGasFee): Promise<MsgUpdateGasFeeResponse> {
-    const data = MsgUpdateGasFee.encode(request).finish()
+    const data = MsgUpdateGasFee.encode(request).finish();
     const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'UpdateGasFee',
+      "KimaFinance.kima.kima.Msg",
+      "UpdateGasFee",
       data
-    )
+    );
     return promise.then((data) =>
       MsgUpdateGasFeeResponse.decode(new Reader(data))
-    )
+    );
   }
 
   ProvisionTransaction(
     request: MsgProvisionTransaction
   ): Promise<MsgProvisionTransactionResponse> {
-    const data = MsgProvisionTransaction.encode(request).finish()
+    const data = MsgProvisionTransaction.encode(request).finish();
     const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'ProvisionTransaction',
+      "KimaFinance.kima.kima.Msg",
+      "ProvisionTransaction",
       data
-    )
+    );
     return promise.then((data) =>
       MsgProvisionTransactionResponse.decode(new Reader(data))
-    )
+    );
   }
 
   DrainTransaction(
     request: MsgDrainTransaction
   ): Promise<MsgDrainTransactionResponse> {
-    const data = MsgDrainTransaction.encode(request).finish()
+    const data = MsgDrainTransaction.encode(request).finish();
     const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'DrainTransaction',
+      "KimaFinance.kima.kima.Msg",
+      "DrainTransaction",
       data
-    )
+    );
     return promise.then((data) =>
       MsgDrainTransactionResponse.decode(new Reader(data))
-    )
+    );
   }
 
   CancelTransaction(
     request: MsgCancelTransaction
   ): Promise<MsgCancelTransactionResponse> {
-    const data = MsgCancelTransaction.encode(request).finish()
+    const data = MsgCancelTransaction.encode(request).finish();
     const promise = this.rpc.request(
-      'DiversifiTechnologies.diversifi.diversifi.Msg',
-      'CancelTransaction',
+      "KimaFinance.kima.kima.Msg",
+      "CancelTransaction",
       data
-    )
+    );
     return promise.then((data) =>
       MsgCancelTransactionResponse.decode(new Reader(data))
-    )
+    );
+  }
+
+  AddWhitelisted(
+    request: MsgAddWhitelisted
+  ): Promise<MsgAddWhitelistedResponse> {
+    const data = MsgAddWhitelisted.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "AddWhitelisted",
+      data
+    );
+    return promise.then((data) =>
+      MsgAddWhitelistedResponse.decode(new Reader(data))
+    );
+  }
+
+  SetAdmin(request: MsgSetAdmin): Promise<MsgSetAdminResponse> {
+    const data = MsgSetAdmin.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "SetAdmin",
+      data
+    );
+    return promise.then((data) => MsgSetAdminResponse.decode(new Reader(data)));
+  }
+
+  AddPubkey(request: MsgAddPubkey): Promise<MsgAddPubkeyResponse> {
+    const data = MsgAddPubkey.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "AddPubkey",
+      data
+    );
+    return promise.then((data) =>
+      MsgAddPubkeyResponse.decode(new Reader(data))
+    );
+  }
+
+  UpdateTssPubkey(
+    request: MsgUpdateTssPubkey
+  ): Promise<MsgUpdateTssPubkeyResponse> {
+    const data = MsgUpdateTssPubkey.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "UpdateTssPubkey",
+      data
+    );
+    return promise.then((data) =>
+      MsgUpdateTssPubkeyResponse.decode(new Reader(data))
+    );
+  }
+
+  RemoveWhitelisted(
+    request: MsgRemoveWhitelisted
+  ): Promise<MsgRemoveWhitelistedResponse> {
+    const data = MsgRemoveWhitelisted.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "RemoveWhitelisted",
+      data
+    );
+    return promise.then((data) =>
+      MsgRemoveWhitelistedResponse.decode(new Reader(data))
+    );
+  }
+
+  ClearTssInfo(request: MsgClearTssInfo): Promise<MsgClearTssInfoResponse> {
+    const data = MsgClearTssInfo.encode(request).finish();
+    const promise = this.rpc.request(
+      "KimaFinance.kima.kima.Msg",
+      "ClearTssInfo",
+      data
+    );
+    return promise.then((data) =>
+      MsgClearTssInfoResponse.decode(new Reader(data))
+    );
   }
 }
 
@@ -2193,10 +3489,10 @@ interface Rpc {
     service: string,
     method: string,
     data: Uint8Array
-  ): Promise<Uint8Array>
+  ): Promise<Uint8Array>;
 }
 
-type Builtin = Date | Function | Uint8Array | string | number | undefined
+type Builtin = Date | Function | Uint8Array | string | number | undefined;
 export type DeepPartial<T> = T extends Builtin
   ? T
   : T extends Array<infer U>
@@ -2205,4 +3501,4 @@ export type DeepPartial<T> = T extends Builtin
   ? ReadonlyArray<DeepPartial<U>>
   : T extends {}
   ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : Partial<T>
+  : Partial<T>;