decentralcardgame-cardchain-client-ts 0.0.29 → 0.0.30

package/cosmos.authz.v1beta1/module.ts

@@ -2,69 +2,72 @@
 
 import { StdFee } from "@cosmjs/amino";
 import { SigningStargateClient, DeliverTxResponse } from "@cosmjs/stargate";
-import { EncodeObject, GeneratedType, OfflineSigner, Registry } from "@cosmjs/proto-signing";
-import { msgTypes } from './registry';
-import { IgniteClient } from "../client"
-import { MissingWalletError } from "../helpers"
+import {
+  EncodeObject,
+  GeneratedType,
+  OfflineSigner,
+  Registry,
+} from "@cosmjs/proto-signing";
+import { msgTypes } from "./registry";
+import { IgniteClient } from "../client";
+import { MissingWalletError } from "../helpers";
 import { Api } from "./rest";
 import { MsgRevoke } from "./types/cosmos/authz/v1beta1/tx";
 import { MsgExec } from "./types/cosmos/authz/v1beta1/tx";
 import { MsgGrant } from "./types/cosmos/authz/v1beta1/tx";
 
-import { GenericAuthorization as typeGenericAuthorization} from "./types"
-import { Grant as typeGrant} from "./types"
-import { GrantAuthorization as typeGrantAuthorization} from "./types"
-import { GrantQueueItem as typeGrantQueueItem} from "./types"
-import { EventGrant as typeEventGrant} from "./types"
-import { EventRevoke as typeEventRevoke} from "./types"
+import { GenericAuthorization as typeGenericAuthorization } from "./types";
+import { Grant as typeGrant } from "./types";
+import { GrantAuthorization as typeGrantAuthorization } from "./types";
+import { GrantQueueItem as typeGrantQueueItem } from "./types";
+import { EventGrant as typeEventGrant } from "./types";
+import { EventRevoke as typeEventRevoke } from "./types";
 
 export { MsgRevoke, MsgExec, MsgGrant };
 
 type sendMsgRevokeParams = {
-  value: MsgRevoke,
-  fee?: StdFee,
-  memo?: string
+  value: MsgRevoke;
+  fee?: StdFee;
+  memo?: string;
 };
 
 type sendMsgExecParams = {
-  value: MsgExec,
-  fee?: StdFee,
-  memo?: string
+  value: MsgExec;
+  fee?: StdFee;
+  memo?: string;
 };
 
 type sendMsgGrantParams = {
-  value: MsgGrant,
-  fee?: StdFee,
-  memo?: string
+  value: MsgGrant;
+  fee?: StdFee;
+  memo?: string;
 };
 
-
 type msgRevokeParams = {
-  value: MsgRevoke,
+  value: MsgRevoke;
 };
 
 type msgExecParams = {
-  value: MsgExec,
+  value: MsgExec;
 };
 
 type msgGrantParams = {
-  value: MsgGrant,
+  value: MsgGrant;
 };
 
-
 export const registry = new Registry(msgTypes);
 
 type Field = {
-	name: string;
-	type: unknown;
-}
+  name: string;
+  type: unknown;
+};
 function getStructure(template) {
-	const structure: {fields: Field[]} = { fields: [] }
-	for (let [key, value] of Object.entries(template)) {
-		let field = { name: key, type: typeof value }
-		structure.fields.push(field)
-	}
-	return structure
+  const structure: { fields: Field[] } = { fields: [] };
+  for (let [key, value] of Object.entries(template)) {
+    let field = { name: key, type: typeof value };
+    structure.fields.push(field);
+  }
+  return structure;
 }
 const defaultFee = {
   amount: [],
@@ -72,136 +75,205 @@ const defaultFee = {
 };
 
 interface TxClientOptions {
-  addr: string
-	prefix: string
-	signer?: OfflineSigner
+  addr: string;
+  prefix: string;
+  signer?: OfflineSigner;
 }
 
-export const txClient = ({ signer, prefix, addr }: TxClientOptions = { addr: "http://localhost:26657", prefix: "cosmos" }) => {
-
+export const txClient = (
+  { signer, prefix, addr }: TxClientOptions = {
+    addr: "http://localhost:26657",
+    prefix: "cosmos",
+  },
+) => {
   return {
-		
-		async sendMsgRevoke({ value, fee, memo }: sendMsgRevokeParams): Promise<DeliverTxResponse> {
-			if (!signer) {
-					throw new Error('TxClient:sendMsgRevoke: Unable to sign Tx. Signer is not present.')
-			}
-			try {			
-				const { address } = (await signer.getAccounts())[0]; 
-				const signingClient = await SigningStargateClient.connectWithSigner(addr,signer,{registry, prefix});
-				let msg = this.msgRevoke({ value: MsgRevoke.fromPartial(value) })
-				return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
-			} catch (e: any) {
-				throw new Error('TxClient:sendMsgRevoke: Could not broadcast Tx: '+ e.message)
-			}
-		},
-		
-		async sendMsgExec({ value, fee, memo }: sendMsgExecParams): Promise<DeliverTxResponse> {
-			if (!signer) {
-					throw new Error('TxClient:sendMsgExec: Unable to sign Tx. Signer is not present.')
-			}
-			try {			
-				const { address } = (await signer.getAccounts())[0]; 
-				const signingClient = await SigningStargateClient.connectWithSigner(addr,signer,{registry, prefix});
-				let msg = this.msgExec({ value: MsgExec.fromPartial(value) })
-				return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
-			} catch (e: any) {
-				throw new Error('TxClient:sendMsgExec: Could not broadcast Tx: '+ e.message)
-			}
-		},
-		
-		async sendMsgGrant({ value, fee, memo }: sendMsgGrantParams): Promise<DeliverTxResponse> {
-			if (!signer) {
-					throw new Error('TxClient:sendMsgGrant: Unable to sign Tx. Signer is not present.')
-			}
-			try {			
-				const { address } = (await signer.getAccounts())[0]; 
-				const signingClient = await SigningStargateClient.connectWithSigner(addr,signer,{registry, prefix});
-				let msg = this.msgGrant({ value: MsgGrant.fromPartial(value) })
-				return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
-			} catch (e: any) {
-				throw new Error('TxClient:sendMsgGrant: Could not broadcast Tx: '+ e.message)
-			}
-		},
-		
-		
-		msgRevoke({ value }: msgRevokeParams): EncodeObject {
-			try {
-				return { typeUrl: "/cosmos.authz.v1beta1.MsgRevoke", value: MsgRevoke.fromPartial( value ) }  
-			} catch (e: any) {
-				throw new Error('TxClient:MsgRevoke: Could not create message: ' + e.message)
-			}
-		},
-		
-		msgExec({ value }: msgExecParams): EncodeObject {
-			try {
-				return { typeUrl: "/cosmos.authz.v1beta1.MsgExec", value: MsgExec.fromPartial( value ) }  
-			} catch (e: any) {
-				throw new Error('TxClient:MsgExec: Could not create message: ' + e.message)
-			}
-		},
-		
-		msgGrant({ value }: msgGrantParams): EncodeObject {
-			try {
-				return { typeUrl: "/cosmos.authz.v1beta1.MsgGrant", value: MsgGrant.fromPartial( value ) }  
-			} catch (e: any) {
-				throw new Error('TxClient:MsgGrant: Could not create message: ' + e.message)
-			}
-		},
-		
-	}
+    async sendMsgRevoke({
+      value,
+      fee,
+      memo,
+    }: sendMsgRevokeParams): Promise<DeliverTxResponse> {
+      if (!signer) {
+        throw new Error(
+          "TxClient:sendMsgRevoke: Unable to sign Tx. Signer is not present.",
+        );
+      }
+      try {
+        const { address } = (await signer.getAccounts())[0];
+        const signingClient = await SigningStargateClient.connectWithSigner(
+          addr,
+          signer,
+          { registry, prefix },
+        );
+        let msg = this.msgRevoke({ value: MsgRevoke.fromPartial(value) });
+        return await signingClient.signAndBroadcast(
+          address,
+          [msg],
+          fee ? fee : defaultFee,
+          memo,
+        );
+      } catch (e: any) {
+        throw new Error(
+          "TxClient:sendMsgRevoke: Could not broadcast Tx: " + e.message,
+        );
+      }
+    },
+
+    async sendMsgExec({
+      value,
+      fee,
+      memo,
+    }: sendMsgExecParams): Promise<DeliverTxResponse> {
+      if (!signer) {
+        throw new Error(
+          "TxClient:sendMsgExec: Unable to sign Tx. Signer is not present.",
+        );
+      }
+      try {
+        const { address } = (await signer.getAccounts())[0];
+        const signingClient = await SigningStargateClient.connectWithSigner(
+          addr,
+          signer,
+          { registry, prefix },
+        );
+        let msg = this.msgExec({ value: MsgExec.fromPartial(value) });
+        return await signingClient.signAndBroadcast(
+          address,
+          [msg],
+          fee ? fee : defaultFee,
+          memo,
+        );
+      } catch (e: any) {
+        throw new Error(
+          "TxClient:sendMsgExec: Could not broadcast Tx: " + e.message,
+        );
+      }
+    },
+
+    async sendMsgGrant({
+      value,
+      fee,
+      memo,
+    }: sendMsgGrantParams): Promise<DeliverTxResponse> {
+      if (!signer) {
+        throw new Error(
+          "TxClient:sendMsgGrant: Unable to sign Tx. Signer is not present.",
+        );
+      }
+      try {
+        const { address } = (await signer.getAccounts())[0];
+        const signingClient = await SigningStargateClient.connectWithSigner(
+          addr,
+          signer,
+          { registry, prefix },
+        );
+        let msg = this.msgGrant({ value: MsgGrant.fromPartial(value) });
+        return await signingClient.signAndBroadcast(
+          address,
+          [msg],
+          fee ? fee : defaultFee,
+          memo,
+        );
+      } catch (e: any) {
+        throw new Error(
+          "TxClient:sendMsgGrant: Could not broadcast Tx: " + e.message,
+        );
+      }
+    },
+
+    msgRevoke({ value }: msgRevokeParams): EncodeObject {
+      try {
+        return {
+          typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+          value: MsgRevoke.fromPartial(value),
+        };
+      } catch (e: any) {
+        throw new Error(
+          "TxClient:MsgRevoke: Could not create message: " + e.message,
+        );
+      }
+    },
+
+    msgExec({ value }: msgExecParams): EncodeObject {
+      try {
+        return {
+          typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+          value: MsgExec.fromPartial(value),
+        };
+      } catch (e: any) {
+        throw new Error(
+          "TxClient:MsgExec: Could not create message: " + e.message,
+        );
+      }
+    },
+
+    msgGrant({ value }: msgGrantParams): EncodeObject {
+      try {
+        return {
+          typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+          value: MsgGrant.fromPartial(value),
+        };
+      } catch (e: any) {
+        throw new Error(
+          "TxClient:MsgGrant: Could not create message: " + e.message,
+        );
+      }
+    },
+  };
 };
 
 interface QueryClientOptions {
-  addr: string
+  addr: string;
 }
 
-export const queryClient = ({ addr: addr }: QueryClientOptions = { addr: "http://localhost:1317" }) => {
+export const queryClient = (
+  { addr: addr }: QueryClientOptions = { addr: "http://localhost:1317" },
+) => {
   return new Api({ baseURL: addr });
 };
 
 class SDKModule {
-	public query: ReturnType<typeof queryClient>;
-	public tx: ReturnType<typeof txClient>;
-	public structure: Record<string,unknown>;
-	public registry: Array<[string, GeneratedType]> = [];
-
-	constructor(client: IgniteClient) {		
-	
-		this.query = queryClient({ addr: client.env.apiURL });		
-		this.updateTX(client);
-		this.structure =  {
-						GenericAuthorization: getStructure(typeGenericAuthorization.fromPartial({})),
-						Grant: getStructure(typeGrant.fromPartial({})),
-						GrantAuthorization: getStructure(typeGrantAuthorization.fromPartial({})),
-						GrantQueueItem: getStructure(typeGrantQueueItem.fromPartial({})),
-						EventGrant: getStructure(typeEventGrant.fromPartial({})),
-						EventRevoke: getStructure(typeEventRevoke.fromPartial({})),
-						
-		};
-		client.on('signer-changed',(signer) => {			
-		 this.updateTX(client);
-		})
-	}
-	updateTX(client: IgniteClient) {
+  public query: ReturnType<typeof queryClient>;
+  public tx: ReturnType<typeof txClient>;
+  public structure: Record<string, unknown>;
+  public registry: Array<[string, GeneratedType]> = [];
+
+  constructor(client: IgniteClient) {
+    this.query = queryClient({ addr: client.env.apiURL });
+    this.updateTX(client);
+    this.structure = {
+      GenericAuthorization: getStructure(
+        typeGenericAuthorization.fromPartial({}),
+      ),
+      Grant: getStructure(typeGrant.fromPartial({})),
+      GrantAuthorization: getStructure(typeGrantAuthorization.fromPartial({})),
+      GrantQueueItem: getStructure(typeGrantQueueItem.fromPartial({})),
+      EventGrant: getStructure(typeEventGrant.fromPartial({})),
+      EventRevoke: getStructure(typeEventRevoke.fromPartial({})),
+    };
+    client.on("signer-changed", (signer) => {
+      this.updateTX(client);
+    });
+  }
+  updateTX(client: IgniteClient) {
     const methods = txClient({
-        signer: client.signer,
-        addr: client.env.rpcURL,
-        prefix: client.env.prefix ?? "cosmos",
-    })
-	
+      signer: client.signer,
+      addr: client.env.rpcURL,
+      prefix: client.env.prefix ?? "cosmos",
+    });
+
     this.tx = methods;
     for (let m in methods) {
-        this.tx[m] = methods[m].bind(this.tx);
+      this.tx[m] = methods[m].bind(this.tx);
     }
-	}
-};
-
-const Module = (test: IgniteClient) => {
-	return {
-		module: {
-			CosmosAuthzV1Beta1: new SDKModule(test)
-		},
-		registry: msgTypes
   }
 }
-export default Module;
+
+const Module = (test: IgniteClient) => {
+  return {
+    module: {
+      CosmosAuthzV1Beta1: new SDKModule(test),
+    },
+    registry: msgTypes,
+  };
+};
+export default Module;

package/cosmos.distribution.v1beta1/module.js

@@ -1,7 +1,7 @@
 // Generated by Ignite ignite.com/cli
 import { SigningStargateClient } from "@cosmjs/stargate";
-import { Registry } from "@cosmjs/proto-signing";
-import { msgTypes } from './registry';
+import { Registry, } from "@cosmjs/proto-signing";
+import { msgTypes } from "./registry";
 import { Api } from "./rest";
 import { MsgWithdrawDelegatorReward } from "./types/cosmos/distribution/v1beta1/tx";
 import { MsgWithdrawValidatorCommission } from "./types/cosmos/distribution/v1beta1/tx";
@@ -26,7 +26,7 @@ import { ValidatorHistoricalRewardsRecord as typeValidatorHistoricalRewardsRecor
 import { ValidatorCurrentRewardsRecord as typeValidatorCurrentRewardsRecord } from "./types";
 import { DelegatorStartingInfoRecord as typeDelegatorStartingInfoRecord } from "./types";
 import { ValidatorSlashEventRecord as typeValidatorSlashEventRecord } from "./types";
-export { MsgWithdrawDelegatorReward, MsgWithdrawValidatorCommission, MsgFundCommunityPool, MsgSetWithdrawAddress };
+export { MsgWithdrawDelegatorReward, MsgWithdrawValidatorCommission, MsgFundCommunityPool, MsgSetWithdrawAddress, };
 export const registry = new Registry(msgTypes);
 function getStructure(template) {
     const structure = { fields: [] };
@@ -40,94 +40,125 @@ const defaultFee = {
     amount: [],
     gas: "200000",
 };
-export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26657", prefix: "cosmos" }) => {
+export const txClient = ({ signer, prefix, addr } = {
+    addr: "http://localhost:26657",
+    prefix: "cosmos",
+}) => {
     return {
-        async sendMsgWithdrawDelegatorReward({ value, fee, memo }) {
+        async sendMsgWithdrawDelegatorReward({ value, fee, memo, }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgWithdrawDelegatorReward: Unable to sign Tx. Signer is not present.');
+                throw new Error("TxClient:sendMsgWithdrawDelegatorReward: Unable to sign Tx. Signer is not present.");
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgWithdrawDelegatorReward({ value: MsgWithdrawDelegatorReward.fromPartial(value) });
+                let msg = this.msgWithdrawDelegatorReward({
+                    value: MsgWithdrawDelegatorReward.fromPartial(value),
+                });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgWithdrawDelegatorReward: Could not broadcast Tx: ' + e.message);
+                throw new Error("TxClient:sendMsgWithdrawDelegatorReward: Could not broadcast Tx: " +
+                    e.message);
             }
         },
-        async sendMsgWithdrawValidatorCommission({ value, fee, memo }) {
+        async sendMsgWithdrawValidatorCommission({ value, fee, memo, }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgWithdrawValidatorCommission: Unable to sign Tx. Signer is not present.');
+                throw new Error("TxClient:sendMsgWithdrawValidatorCommission: Unable to sign Tx. Signer is not present.");
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgWithdrawValidatorCommission({ value: MsgWithdrawValidatorCommission.fromPartial(value) });
+                let msg = this.msgWithdrawValidatorCommission({
+                    value: MsgWithdrawValidatorCommission.fromPartial(value),
+                });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgWithdrawValidatorCommission: Could not broadcast Tx: ' + e.message);
+                throw new Error("TxClient:sendMsgWithdrawValidatorCommission: Could not broadcast Tx: " +
+                    e.message);
             }
         },
-        async sendMsgFundCommunityPool({ value, fee, memo }) {
+        async sendMsgFundCommunityPool({ value, fee, memo, }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgFundCommunityPool: Unable to sign Tx. Signer is not present.');
+                throw new Error("TxClient:sendMsgFundCommunityPool: Unable to sign Tx. Signer is not present.");
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgFundCommunityPool({ value: MsgFundCommunityPool.fromPartial(value) });
+                let msg = this.msgFundCommunityPool({
+                    value: MsgFundCommunityPool.fromPartial(value),
+                });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgFundCommunityPool: Could not broadcast Tx: ' + e.message);
+                throw new Error("TxClient:sendMsgFundCommunityPool: Could not broadcast Tx: " +
+                    e.message);
             }
         },
-        async sendMsgSetWithdrawAddress({ value, fee, memo }) {
+        async sendMsgSetWithdrawAddress({ value, fee, memo, }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetWithdrawAddress: Unable to sign Tx. Signer is not present.');
+                throw new Error("TxClient:sendMsgSetWithdrawAddress: Unable to sign Tx. Signer is not present.");
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgSetWithdrawAddress({ value: MsgSetWithdrawAddress.fromPartial(value) });
+                let msg = this.msgSetWithdrawAddress({
+                    value: MsgSetWithdrawAddress.fromPartial(value),
+                });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgSetWithdrawAddress: Could not broadcast Tx: ' + e.message);
+                throw new Error("TxClient:sendMsgSetWithdrawAddress: Could not broadcast Tx: " +
+                    e.message);
             }
         },
-        msgWithdrawDelegatorReward({ value }) {
+        msgWithdrawDelegatorReward({ value, }) {
             try {
-                return { typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward", value: MsgWithdrawDelegatorReward.fromPartial(value) };
+                return {
+                    typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+                    value: MsgWithdrawDelegatorReward.fromPartial(value),
+                };
             }
             catch (e) {
-                throw new Error('TxClient:MsgWithdrawDelegatorReward: Could not create message: ' + e.message);
+                throw new Error("TxClient:MsgWithdrawDelegatorReward: Could not create message: " +
+                    e.message);
             }
         },
-        msgWithdrawValidatorCommission({ value }) {
+        msgWithdrawValidatorCommission({ value, }) {
             try {
-                return { typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission", value: MsgWithdrawValidatorCommission.fromPartial(value) };
+                return {
+                    typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission",
+                    value: MsgWithdrawValidatorCommission.fromPartial(value),
+                };
             }
             catch (e) {
-                throw new Error('TxClient:MsgWithdrawValidatorCommission: Could not create message: ' + e.message);
+                throw new Error("TxClient:MsgWithdrawValidatorCommission: Could not create message: " +
+                    e.message);
             }
         },
         msgFundCommunityPool({ value }) {
             try {
-                return { typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool", value: MsgFundCommunityPool.fromPartial(value) };
+                return {
+                    typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool",
+                    value: MsgFundCommunityPool.fromPartial(value),
+                };
             }
             catch (e) {
-                throw new Error('TxClient:MsgFundCommunityPool: Could not create message: ' + e.message);
+                throw new Error("TxClient:MsgFundCommunityPool: Could not create message: " +
+                    e.message);
             }
         },
-        msgSetWithdrawAddress({ value }) {
+        msgSetWithdrawAddress({ value, }) {
             try {
-                return { typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress", value: MsgSetWithdrawAddress.fromPartial(value) };
+                return {
+                    typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress",
+                    value: MsgSetWithdrawAddress.fromPartial(value),
+                };
             }
             catch (e) {
-                throw new Error('TxClient:MsgSetWithdrawAddress: Could not create message: ' + e.message);
+                throw new Error("TxClient:MsgSetWithdrawAddress: Could not create message: " +
+                    e.message);
             }
         },
     };
@@ -161,7 +192,7 @@ class SDKModule {
             DelegatorStartingInfoRecord: getStructure(typeDelegatorStartingInfoRecord.fromPartial({})),
             ValidatorSlashEventRecord: getStructure(typeValidatorSlashEventRecord.fromPartial({})),
         };
-        client.on('signer-changed', (signer) => {
+        client.on("signer-changed", (signer) => {
             this.updateTX(client);
         });
     }
@@ -177,13 +208,12 @@ class SDKModule {
         }
     }
 }
-;
 const Module = (test) => {
     return {
         module: {
-            CosmosDistributionV1Beta1: new SDKModule(test)
+            CosmosDistributionV1Beta1: new SDKModule(test),
         },
-        registry: msgTypes
+        registry: msgTypes,
     };
 };
 export default Module;