decentralcardgame-cardchain-client-ts 0.0.28 → 0.0.29

package/DecentralCardGame.cardchain.cardchain/module.ts

@@ -7,48 +7,48 @@ import {msgTypes} from './registry';
 import {IgniteClient} from "../client"
 import {MissingWalletError} from "../helpers"
 import {Api} from "./rest";
-import {MsgSetUserWebsite} from "./types/cardchain/cardchain/tx";
-import {MsgBuyCard} from "./types/cardchain/cardchain/tx";
-import {MsgSetSetStoryWriter} from "./types/cardchain/cardchain/tx";
-import {MsgChangeAlias} from "./types/cardchain/cardchain/tx";
+import {MsgBuyCardScheme} from "./types/cardchain/cardchain/tx";
+import {MsgAddArtwork} from "./types/cardchain/cardchain/tx";
+import {MsgSetSetName} from "./types/cardchain/cardchain/tx";
+import {MsgConfirmMatch} from "./types/cardchain/cardchain/tx";
 import {MsgTransferBoosterPack} from "./types/cardchain/cardchain/tx";
-import {MsgRevealCouncilResponse} from "./types/cardchain/cardchain/tx";
-import {MsgRewokeCouncilRegistration} from "./types/cardchain/cardchain/tx";
-import {MsgRestartCouncil} from "./types/cardchain/cardchain/tx";
-import {MsgSetSetArtist} from "./types/cardchain/cardchain/tx";
+import {MsgMultiVoteCard} from "./types/cardchain/cardchain/tx";
 import {MsgFinalizeSet} from "./types/cardchain/cardchain/tx";
-import {MsgOpenMatch} from "./types/cardchain/cardchain/tx";
+import {MsgOpenBoosterPack} from "./types/cardchain/cardchain/tx";
+import {MsgTransferCard} from "./types/cardchain/cardchain/tx";
+import {MsgRemoveContributorFromSet} from "./types/cardchain/cardchain/tx";
+import {MsgChangeAlias} from "./types/cardchain/cardchain/tx";
+import {MsgRemoveSellOffer} from "./types/cardchain/cardchain/tx";
+import {MsgApointMatchReporter} from "./types/cardchain/cardchain/tx";
 import {MsgAddArtworkToSet} from "./types/cardchain/cardchain/tx";
-import {MsgConfirmMatch} from "./types/cardchain/cardchain/tx";
-import {MsgCreateSellOffer} from "./types/cardchain/cardchain/tx";
+import {MsgAddStoryToSet} from "./types/cardchain/cardchain/tx";
+import {MsgRevealCouncilResponse} from "./types/cardchain/cardchain/tx";
+import {MsgSetSetArtist} from "./types/cardchain/cardchain/tx";
+import {MsgReportMatch} from "./types/cardchain/cardchain/tx";
+import {MsgCreateCouncil} from "./types/cardchain/cardchain/tx";
+import {MsgSaveCardContent} from "./types/cardchain/cardchain/tx";
+import {MsgSetUserBiography} from "./types/cardchain/cardchain/tx";
+import {MsgAddCardToSet} from "./types/cardchain/cardchain/tx";
+import {MsgCreateSet} from "./types/cardchain/cardchain/tx";
 import {MsgDisinviteEarlyAccess} from "./types/cardchain/cardchain/tx";
+import {MsgVoteCard} from "./types/cardchain/cardchain/tx";
+import {MsgSetUserWebsite} from "./types/cardchain/cardchain/tx";
+import {MsgSetSetStoryWriter} from "./types/cardchain/cardchain/tx";
+import {MsgRewokeCouncilRegistration} from "./types/cardchain/cardchain/tx";
 import {MsgCommitCouncilResponse} from "./types/cardchain/cardchain/tx";
-import {MsgSetProfileCard} from "./types/cardchain/cardchain/tx";
-import {MsgSaveCardContent} from "./types/cardchain/cardchain/tx";
-import {MsgApointMatchReporter} from "./types/cardchain/cardchain/tx";
-import {MsgAddStoryToSet} from "./types/cardchain/cardchain/tx";
+import {MsgBuyBoosterPack} from "./types/cardchain/cardchain/tx";
+import {MsgAddContributorToSet} from "./types/cardchain/cardchain/tx";
 import {MsgRegisterForCouncil} from "./types/cardchain/cardchain/tx";
-import {MsgVoteCard} from "./types/cardchain/cardchain/tx";
-import {MsgAddArtwork} from "./types/cardchain/cardchain/tx";
-import {MsgSetCardRarity} from "./types/cardchain/cardchain/tx";
-import {MsgAddCardToSet} from "./types/cardchain/cardchain/tx";
+import {MsgOpenMatch} from "./types/cardchain/cardchain/tx";
+import {MsgSetProfileCard} from "./types/cardchain/cardchain/tx";
 import {MsgChangeArtist} from "./types/cardchain/cardchain/tx";
-import {MsgReportMatch} from "./types/cardchain/cardchain/tx";
-import {MsgRemoveSellOffer} from "./types/cardchain/cardchain/tx";
-import {MsgMultiVoteCard} from "./types/cardchain/cardchain/tx";
-import {MsgBuyCardScheme} from "./types/cardchain/cardchain/tx";
-import {MsgTransferCard} from "./types/cardchain/cardchain/tx";
-import {MsgBuyBoosterPack} from "./types/cardchain/cardchain/tx";
-import {MsgCreateCouncil} from "./types/cardchain/cardchain/tx";
 import {MsgDonateToCard} from "./types/cardchain/cardchain/tx";
-import {MsgAddContributorToSet} from "./types/cardchain/cardchain/tx";
-import {MsgOpenBoosterPack} from "./types/cardchain/cardchain/tx";
-import {MsgRemoveCardFromSet} from "./types/cardchain/cardchain/tx";
-import {MsgSetUserBiography} from "./types/cardchain/cardchain/tx";
+import {MsgBuyCard} from "./types/cardchain/cardchain/tx";
 import {MsgCreateuser} from "./types/cardchain/cardchain/tx";
-import {MsgCreateSet} from "./types/cardchain/cardchain/tx";
-import {MsgRemoveContributorFromSet} from "./types/cardchain/cardchain/tx";
-import {MsgSetSetName} from "./types/cardchain/cardchain/tx";
+import {MsgRemoveCardFromSet} from "./types/cardchain/cardchain/tx";
+import {MsgCreateSellOffer} from "./types/cardchain/cardchain/tx";
+import {MsgRestartCouncil} from "./types/cardchain/cardchain/tx";
+import {MsgSetCardRarity} from "./types/cardchain/cardchain/tx";
 import {MsgInviteEarlyAccess} from "./types/cardchain/cardchain/tx";
 
 import {Card as typeCard} from "./types"
@@ -77,71 +77,71 @@ import {VotingResult as typeVotingResult} from "./types"
 import {SingleVote as typeSingleVote} from "./types"
 
 export {
-    MsgSetUserWebsite,
-    MsgBuyCard,
-    MsgSetSetStoryWriter,
-    MsgChangeAlias,
+    MsgBuyCardScheme,
+    MsgAddArtwork,
+    MsgSetSetName,
+    MsgConfirmMatch,
     MsgTransferBoosterPack,
-    MsgRevealCouncilResponse,
-    MsgRewokeCouncilRegistration,
-    MsgRestartCouncil,
-    MsgSetSetArtist,
+    MsgMultiVoteCard,
     MsgFinalizeSet,
-    MsgOpenMatch,
+    MsgOpenBoosterPack,
+    MsgTransferCard,
+    MsgRemoveContributorFromSet,
+    MsgChangeAlias,
+    MsgRemoveSellOffer,
+    MsgApointMatchReporter,
     MsgAddArtworkToSet,
-    MsgConfirmMatch,
-    MsgCreateSellOffer,
+    MsgAddStoryToSet,
+    MsgRevealCouncilResponse,
+    MsgSetSetArtist,
+    MsgReportMatch,
+    MsgCreateCouncil,
+    MsgSaveCardContent,
+    MsgSetUserBiography,
+    MsgAddCardToSet,
+    MsgCreateSet,
     MsgDisinviteEarlyAccess,
+    MsgVoteCard,
+    MsgSetUserWebsite,
+    MsgSetSetStoryWriter,
+    MsgRewokeCouncilRegistration,
     MsgCommitCouncilResponse,
-    MsgSetProfileCard,
-    MsgSaveCardContent,
-    MsgApointMatchReporter,
-    MsgAddStoryToSet,
+    MsgBuyBoosterPack,
+    MsgAddContributorToSet,
     MsgRegisterForCouncil,
-    MsgVoteCard,
-    MsgAddArtwork,
-    MsgSetCardRarity,
-    MsgAddCardToSet,
+    MsgOpenMatch,
+    MsgSetProfileCard,
     MsgChangeArtist,
-    MsgReportMatch,
-    MsgRemoveSellOffer,
-    MsgMultiVoteCard,
-    MsgBuyCardScheme,
-    MsgTransferCard,
-    MsgBuyBoosterPack,
-    MsgCreateCouncil,
     MsgDonateToCard,
-    MsgAddContributorToSet,
-    MsgOpenBoosterPack,
-    MsgRemoveCardFromSet,
-    MsgSetUserBiography,
+    MsgBuyCard,
     MsgCreateuser,
-    MsgCreateSet,
-    MsgRemoveContributorFromSet,
-    MsgSetSetName,
+    MsgRemoveCardFromSet,
+    MsgCreateSellOffer,
+    MsgRestartCouncil,
+    MsgSetCardRarity,
     MsgInviteEarlyAccess
 };
 
-type sendMsgSetUserWebsiteParams = {
-    value: MsgSetUserWebsite,
+type sendMsgBuyCardSchemeParams = {
+    value: MsgBuyCardScheme,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgBuyCardParams = {
-    value: MsgBuyCard,
+type sendMsgAddArtworkParams = {
+    value: MsgAddArtwork,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetSetStoryWriterParams = {
-    value: MsgSetSetStoryWriter,
+type sendMsgSetSetNameParams = {
+    value: MsgSetSetName,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgChangeAliasParams = {
-    value: MsgChangeAlias,
+type sendMsgConfirmMatchParams = {
+    value: MsgConfirmMatch,
     fee?: StdFee,
     memo?: string
 };
@@ -152,224 +152,224 @@ type sendMsgTransferBoosterPackParams = {
     memo?: string
 };
 
-type sendMsgRevealCouncilResponseParams = {
-    value: MsgRevealCouncilResponse,
+type sendMsgMultiVoteCardParams = {
+    value: MsgMultiVoteCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRewokeCouncilRegistrationParams = {
-    value: MsgRewokeCouncilRegistration,
+type sendMsgFinalizeSetParams = {
+    value: MsgFinalizeSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRestartCouncilParams = {
-    value: MsgRestartCouncil,
+type sendMsgOpenBoosterPackParams = {
+    value: MsgOpenBoosterPack,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetSetArtistParams = {
-    value: MsgSetSetArtist,
+type sendMsgTransferCardParams = {
+    value: MsgTransferCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgFinalizeSetParams = {
-    value: MsgFinalizeSet,
+type sendMsgRemoveContributorFromSetParams = {
+    value: MsgRemoveContributorFromSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgOpenMatchParams = {
-    value: MsgOpenMatch,
+type sendMsgChangeAliasParams = {
+    value: MsgChangeAlias,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddArtworkToSetParams = {
-    value: MsgAddArtworkToSet,
+type sendMsgRemoveSellOfferParams = {
+    value: MsgRemoveSellOffer,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgConfirmMatchParams = {
-    value: MsgConfirmMatch,
+type sendMsgApointMatchReporterParams = {
+    value: MsgApointMatchReporter,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCreateSellOfferParams = {
-    value: MsgCreateSellOffer,
+type sendMsgAddArtworkToSetParams = {
+    value: MsgAddArtworkToSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgDisinviteEarlyAccessParams = {
-    value: MsgDisinviteEarlyAccess,
+type sendMsgAddStoryToSetParams = {
+    value: MsgAddStoryToSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCommitCouncilResponseParams = {
-    value: MsgCommitCouncilResponse,
+type sendMsgRevealCouncilResponseParams = {
+    value: MsgRevealCouncilResponse,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetProfileCardParams = {
-    value: MsgSetProfileCard,
+type sendMsgSetSetArtistParams = {
+    value: MsgSetSetArtist,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSaveCardContentParams = {
-    value: MsgSaveCardContent,
+type sendMsgReportMatchParams = {
+    value: MsgReportMatch,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgApointMatchReporterParams = {
-    value: MsgApointMatchReporter,
+type sendMsgCreateCouncilParams = {
+    value: MsgCreateCouncil,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddStoryToSetParams = {
-    value: MsgAddStoryToSet,
+type sendMsgSaveCardContentParams = {
+    value: MsgSaveCardContent,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRegisterForCouncilParams = {
-    value: MsgRegisterForCouncil,
+type sendMsgSetUserBiographyParams = {
+    value: MsgSetUserBiography,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgVoteCardParams = {
-    value: MsgVoteCard,
+type sendMsgAddCardToSetParams = {
+    value: MsgAddCardToSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddArtworkParams = {
-    value: MsgAddArtwork,
+type sendMsgCreateSetParams = {
+    value: MsgCreateSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetCardRarityParams = {
-    value: MsgSetCardRarity,
+type sendMsgDisinviteEarlyAccessParams = {
+    value: MsgDisinviteEarlyAccess,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddCardToSetParams = {
-    value: MsgAddCardToSet,
+type sendMsgVoteCardParams = {
+    value: MsgVoteCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgChangeArtistParams = {
-    value: MsgChangeArtist,
+type sendMsgSetUserWebsiteParams = {
+    value: MsgSetUserWebsite,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgReportMatchParams = {
-    value: MsgReportMatch,
+type sendMsgSetSetStoryWriterParams = {
+    value: MsgSetSetStoryWriter,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRemoveSellOfferParams = {
-    value: MsgRemoveSellOffer,
+type sendMsgRewokeCouncilRegistrationParams = {
+    value: MsgRewokeCouncilRegistration,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgMultiVoteCardParams = {
-    value: MsgMultiVoteCard,
+type sendMsgCommitCouncilResponseParams = {
+    value: MsgCommitCouncilResponse,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgBuyCardSchemeParams = {
-    value: MsgBuyCardScheme,
+type sendMsgBuyBoosterPackParams = {
+    value: MsgBuyBoosterPack,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgTransferCardParams = {
-    value: MsgTransferCard,
+type sendMsgAddContributorToSetParams = {
+    value: MsgAddContributorToSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgBuyBoosterPackParams = {
-    value: MsgBuyBoosterPack,
+type sendMsgRegisterForCouncilParams = {
+    value: MsgRegisterForCouncil,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCreateCouncilParams = {
-    value: MsgCreateCouncil,
+type sendMsgOpenMatchParams = {
+    value: MsgOpenMatch,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgDonateToCardParams = {
-    value: MsgDonateToCard,
+type sendMsgSetProfileCardParams = {
+    value: MsgSetProfileCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddContributorToSetParams = {
-    value: MsgAddContributorToSet,
+type sendMsgChangeArtistParams = {
+    value: MsgChangeArtist,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgOpenBoosterPackParams = {
-    value: MsgOpenBoosterPack,
+type sendMsgDonateToCardParams = {
+    value: MsgDonateToCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRemoveCardFromSetParams = {
-    value: MsgRemoveCardFromSet,
+type sendMsgBuyCardParams = {
+    value: MsgBuyCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetUserBiographyParams = {
-    value: MsgSetUserBiography,
+type sendMsgCreateuserParams = {
+    value: MsgCreateuser,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCreateuserParams = {
-    value: MsgCreateuser,
+type sendMsgRemoveCardFromSetParams = {
+    value: MsgRemoveCardFromSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCreateSetParams = {
-    value: MsgCreateSet,
+type sendMsgCreateSellOfferParams = {
+    value: MsgCreateSellOffer,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRemoveContributorFromSetParams = {
-    value: MsgRemoveContributorFromSet,
+type sendMsgRestartCouncilParams = {
+    value: MsgRestartCouncil,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetSetNameParams = {
-    value: MsgSetSetName,
+type sendMsgSetCardRarityParams = {
+    value: MsgSetCardRarity,
     fee?: StdFee,
     memo?: string
 };
@@ -381,172 +381,172 @@ type sendMsgInviteEarlyAccessParams = {
 };
 
 
-type msgSetUserWebsiteParams = {
-    value: MsgSetUserWebsite,
+type msgBuyCardSchemeParams = {
+    value: MsgBuyCardScheme,
 };
 
-type msgBuyCardParams = {
-    value: MsgBuyCard,
+type msgAddArtworkParams = {
+    value: MsgAddArtwork,
 };
 
-type msgSetSetStoryWriterParams = {
-    value: MsgSetSetStoryWriter,
+type msgSetSetNameParams = {
+    value: MsgSetSetName,
 };
 
-type msgChangeAliasParams = {
-    value: MsgChangeAlias,
+type msgConfirmMatchParams = {
+    value: MsgConfirmMatch,
 };
 
 type msgTransferBoosterPackParams = {
     value: MsgTransferBoosterPack,
 };
 
-type msgRevealCouncilResponseParams = {
-    value: MsgRevealCouncilResponse,
-};
-
-type msgRewokeCouncilRegistrationParams = {
-    value: MsgRewokeCouncilRegistration,
-};
-
-type msgRestartCouncilParams = {
-    value: MsgRestartCouncil,
-};
-
-type msgSetSetArtistParams = {
-    value: MsgSetSetArtist,
+type msgMultiVoteCardParams = {
+    value: MsgMultiVoteCard,
 };
 
 type msgFinalizeSetParams = {
     value: MsgFinalizeSet,
 };
 
-type msgOpenMatchParams = {
-    value: MsgOpenMatch,
+type msgOpenBoosterPackParams = {
+    value: MsgOpenBoosterPack,
 };
 
-type msgAddArtworkToSetParams = {
-    value: MsgAddArtworkToSet,
+type msgTransferCardParams = {
+    value: MsgTransferCard,
 };
 
-type msgConfirmMatchParams = {
-    value: MsgConfirmMatch,
+type msgRemoveContributorFromSetParams = {
+    value: MsgRemoveContributorFromSet,
 };
 
-type msgCreateSellOfferParams = {
-    value: MsgCreateSellOffer,
+type msgChangeAliasParams = {
+    value: MsgChangeAlias,
 };
 
-type msgDisinviteEarlyAccessParams = {
-    value: MsgDisinviteEarlyAccess,
+type msgRemoveSellOfferParams = {
+    value: MsgRemoveSellOffer,
 };
 
-type msgCommitCouncilResponseParams = {
-    value: MsgCommitCouncilResponse,
+type msgApointMatchReporterParams = {
+    value: MsgApointMatchReporter,
 };
 
-type msgSetProfileCardParams = {
-    value: MsgSetProfileCard,
+type msgAddArtworkToSetParams = {
+    value: MsgAddArtworkToSet,
 };
 
-type msgSaveCardContentParams = {
-    value: MsgSaveCardContent,
+type msgAddStoryToSetParams = {
+    value: MsgAddStoryToSet,
 };
 
-type msgApointMatchReporterParams = {
-    value: MsgApointMatchReporter,
+type msgRevealCouncilResponseParams = {
+    value: MsgRevealCouncilResponse,
 };
 
-type msgAddStoryToSetParams = {
-    value: MsgAddStoryToSet,
+type msgSetSetArtistParams = {
+    value: MsgSetSetArtist,
 };
 
-type msgRegisterForCouncilParams = {
-    value: MsgRegisterForCouncil,
+type msgReportMatchParams = {
+    value: MsgReportMatch,
 };
 
-type msgVoteCardParams = {
-    value: MsgVoteCard,
+type msgCreateCouncilParams = {
+    value: MsgCreateCouncil,
 };
 
-type msgAddArtworkParams = {
-    value: MsgAddArtwork,
+type msgSaveCardContentParams = {
+    value: MsgSaveCardContent,
 };
 
-type msgSetCardRarityParams = {
-    value: MsgSetCardRarity,
+type msgSetUserBiographyParams = {
+    value: MsgSetUserBiography,
 };
 
 type msgAddCardToSetParams = {
     value: MsgAddCardToSet,
 };
 
-type msgChangeArtistParams = {
-    value: MsgChangeArtist,
+type msgCreateSetParams = {
+    value: MsgCreateSet,
 };
 
-type msgReportMatchParams = {
-    value: MsgReportMatch,
+type msgDisinviteEarlyAccessParams = {
+    value: MsgDisinviteEarlyAccess,
 };
 
-type msgRemoveSellOfferParams = {
-    value: MsgRemoveSellOffer,
+type msgVoteCardParams = {
+    value: MsgVoteCard,
+};
+
+type msgSetUserWebsiteParams = {
+    value: MsgSetUserWebsite,
 };
 
-type msgMultiVoteCardParams = {
-    value: MsgMultiVoteCard,
+type msgSetSetStoryWriterParams = {
+    value: MsgSetSetStoryWriter,
 };
 
-type msgBuyCardSchemeParams = {
-    value: MsgBuyCardScheme,
+type msgRewokeCouncilRegistrationParams = {
+    value: MsgRewokeCouncilRegistration,
 };
 
-type msgTransferCardParams = {
-    value: MsgTransferCard,
+type msgCommitCouncilResponseParams = {
+    value: MsgCommitCouncilResponse,
 };
 
 type msgBuyBoosterPackParams = {
     value: MsgBuyBoosterPack,
 };
 
-type msgCreateCouncilParams = {
-    value: MsgCreateCouncil,
+type msgAddContributorToSetParams = {
+    value: MsgAddContributorToSet,
 };
 
-type msgDonateToCardParams = {
-    value: MsgDonateToCard,
+type msgRegisterForCouncilParams = {
+    value: MsgRegisterForCouncil,
 };
 
-type msgAddContributorToSetParams = {
-    value: MsgAddContributorToSet,
+type msgOpenMatchParams = {
+    value: MsgOpenMatch,
 };
 
-type msgOpenBoosterPackParams = {
-    value: MsgOpenBoosterPack,
+type msgSetProfileCardParams = {
+    value: MsgSetProfileCard,
 };
 
-type msgRemoveCardFromSetParams = {
-    value: MsgRemoveCardFromSet,
+type msgChangeArtistParams = {
+    value: MsgChangeArtist,
 };
 
-type msgSetUserBiographyParams = {
-    value: MsgSetUserBiography,
+type msgDonateToCardParams = {
+    value: MsgDonateToCard,
+};
+
+type msgBuyCardParams = {
+    value: MsgBuyCard,
 };
 
 type msgCreateuserParams = {
     value: MsgCreateuser,
 };
 
-type msgCreateSetParams = {
-    value: MsgCreateSet,
+type msgRemoveCardFromSetParams = {
+    value: MsgRemoveCardFromSet,
 };
 
-type msgRemoveContributorFromSetParams = {
-    value: MsgRemoveContributorFromSet,
+type msgCreateSellOfferParams = {
+    value: MsgCreateSellOffer,
 };
 
-type msgSetSetNameParams = {
-    value: MsgSetSetName,
+type msgRestartCouncilParams = {
+    value: MsgRestartCouncil,
+};
+
+type msgSetCardRarityParams = {
+    value: MsgSetCardRarity,
 };
 
 type msgInviteEarlyAccessParams = {
@@ -588,59 +588,59 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
 
     return {
 
-        async sendMsgSetUserWebsite({value, fee, memo}: sendMsgSetUserWebsiteParams): Promise<DeliverTxResponse> {
+        async sendMsgBuyCardScheme({value, fee, memo}: sendMsgBuyCardSchemeParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetUserWebsite: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgBuyCardScheme: 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.msgSetUserWebsite({value: MsgSetUserWebsite.fromPartial(value)})
+                let msg = this.msgBuyCardScheme({value: MsgBuyCardScheme.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSetUserWebsite: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgBuyCardScheme: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgBuyCard({value, fee, memo}: sendMsgBuyCardParams): Promise<DeliverTxResponse> {
+        async sendMsgAddArtwork({value, fee, memo}: sendMsgAddArtworkParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBuyCard: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgAddArtwork: 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.msgBuyCard({value: MsgBuyCard.fromPartial(value)})
+                let msg = this.msgAddArtwork({value: MsgAddArtwork.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgBuyCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddArtwork: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetSetStoryWriter({value, fee, memo}: sendMsgSetSetStoryWriterParams): Promise<DeliverTxResponse> {
+        async sendMsgSetSetName({value, fee, memo}: sendMsgSetSetNameParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetSetStoryWriter: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSetSetName: 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.msgSetSetStoryWriter({value: MsgSetSetStoryWriter.fromPartial(value)})
+                let msg = this.msgSetSetName({value: MsgSetSetName.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSetSetStoryWriter: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetSetName: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgChangeAlias({value, fee, memo}: sendMsgChangeAliasParams): Promise<DeliverTxResponse> {
+        async sendMsgConfirmMatch({value, fee, memo}: sendMsgConfirmMatchParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgChangeAlias: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgConfirmMatch: 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.msgChangeAlias({value: MsgChangeAlias.fromPartial(value)})
+                let msg = this.msgConfirmMatch({value: MsgConfirmMatch.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgChangeAlias: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgConfirmMatch: Could not broadcast Tx: ' + e.message)
             }
         },
 
@@ -662,553 +662,553 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        async sendMsgRevealCouncilResponse({
-                                               value,
-                                               fee,
-                                               memo
-                                           }: sendMsgRevealCouncilResponseParams): Promise<DeliverTxResponse> {
+        async sendMsgMultiVoteCard({value, fee, memo}: sendMsgMultiVoteCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRevealCouncilResponse: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgMultiVoteCard: 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.msgRevealCouncilResponse({value: MsgRevealCouncilResponse.fromPartial(value)})
+                let msg = this.msgMultiVoteCard({value: MsgMultiVoteCard.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgRevealCouncilResponse: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgMultiVoteCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRewokeCouncilRegistration({
-                                                   value,
-                                                   fee,
-                                                   memo
-                                               }: sendMsgRewokeCouncilRegistrationParams): Promise<DeliverTxResponse> {
+        async sendMsgFinalizeSet({value, fee, memo}: sendMsgFinalizeSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRewokeCouncilRegistration: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgFinalizeSet: 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.msgRewokeCouncilRegistration({value: MsgRewokeCouncilRegistration.fromPartial(value)})
+                let msg = this.msgFinalizeSet({value: MsgFinalizeSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgRewokeCouncilRegistration: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgFinalizeSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRestartCouncil({value, fee, memo}: sendMsgRestartCouncilParams): Promise<DeliverTxResponse> {
+        async sendMsgOpenBoosterPack({value, fee, memo}: sendMsgOpenBoosterPackParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRestartCouncil: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgOpenBoosterPack: 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.msgRestartCouncil({value: MsgRestartCouncil.fromPartial(value)})
+                let msg = this.msgOpenBoosterPack({value: MsgOpenBoosterPack.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgRestartCouncil: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgOpenBoosterPack: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetSetArtist({value, fee, memo}: sendMsgSetSetArtistParams): Promise<DeliverTxResponse> {
+        async sendMsgTransferCard({value, fee, memo}: sendMsgTransferCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetSetArtist: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgTransferCard: 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.msgSetSetArtist({value: MsgSetSetArtist.fromPartial(value)})
+                let msg = this.msgTransferCard({value: MsgTransferCard.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSetSetArtist: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgTransferCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgFinalizeSet({value, fee, memo}: sendMsgFinalizeSetParams): Promise<DeliverTxResponse> {
+        async sendMsgRemoveContributorFromSet({
+                                                  value,
+                                                  fee,
+                                                  memo
+                                              }: sendMsgRemoveContributorFromSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgFinalizeSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgRemoveContributorFromSet: 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.msgFinalizeSet({value: MsgFinalizeSet.fromPartial(value)})
+                let msg = this.msgRemoveContributorFromSet({value: MsgRemoveContributorFromSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgFinalizeSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRemoveContributorFromSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgOpenMatch({value, fee, memo}: sendMsgOpenMatchParams): Promise<DeliverTxResponse> {
+        async sendMsgChangeAlias({value, fee, memo}: sendMsgChangeAliasParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgOpenMatch: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgChangeAlias: 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.msgOpenMatch({value: MsgOpenMatch.fromPartial(value)})
+                let msg = this.msgChangeAlias({value: MsgChangeAlias.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgOpenMatch: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgChangeAlias: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddArtworkToSet({value, fee, memo}: sendMsgAddArtworkToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgRemoveSellOffer({value, fee, memo}: sendMsgRemoveSellOfferParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddArtworkToSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgRemoveSellOffer: 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.msgAddArtworkToSet({value: MsgAddArtworkToSet.fromPartial(value)})
+                let msg = this.msgRemoveSellOffer({value: MsgRemoveSellOffer.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgAddArtworkToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRemoveSellOffer: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgConfirmMatch({value, fee, memo}: sendMsgConfirmMatchParams): Promise<DeliverTxResponse> {
+        async sendMsgApointMatchReporter({
+                                             value,
+                                             fee,
+                                             memo
+                                         }: sendMsgApointMatchReporterParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgConfirmMatch: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgApointMatchReporter: 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.msgConfirmMatch({value: MsgConfirmMatch.fromPartial(value)})
+                let msg = this.msgApointMatchReporter({value: MsgApointMatchReporter.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgConfirmMatch: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgApointMatchReporter: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCreateSellOffer({value, fee, memo}: sendMsgCreateSellOfferParams): Promise<DeliverTxResponse> {
+        async sendMsgAddArtworkToSet({value, fee, memo}: sendMsgAddArtworkToSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateSellOffer: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgAddArtworkToSet: 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.msgCreateSellOffer({value: MsgCreateSellOffer.fromPartial(value)})
+                let msg = this.msgAddArtworkToSet({value: MsgAddArtworkToSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgCreateSellOffer: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddArtworkToSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgDisinviteEarlyAccess({
-                                              value,
-                                              fee,
-                                              memo
-                                          }: sendMsgDisinviteEarlyAccessParams): Promise<DeliverTxResponse> {
+        async sendMsgAddStoryToSet({value, fee, memo}: sendMsgAddStoryToSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgDisinviteEarlyAccess: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgAddStoryToSet: 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.msgDisinviteEarlyAccess({value: MsgDisinviteEarlyAccess.fromPartial(value)})
+                let msg = this.msgAddStoryToSet({value: MsgAddStoryToSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgDisinviteEarlyAccess: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddStoryToSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCommitCouncilResponse({
+        async sendMsgRevealCouncilResponse({
                                                value,
                                                fee,
                                                memo
-                                           }: sendMsgCommitCouncilResponseParams): Promise<DeliverTxResponse> {
+                                           }: sendMsgRevealCouncilResponseParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCommitCouncilResponse: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgRevealCouncilResponse: 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.msgCommitCouncilResponse({value: MsgCommitCouncilResponse.fromPartial(value)})
+                let msg = this.msgRevealCouncilResponse({value: MsgRevealCouncilResponse.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgCommitCouncilResponse: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRevealCouncilResponse: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetProfileCard({value, fee, memo}: sendMsgSetProfileCardParams): Promise<DeliverTxResponse> {
+        async sendMsgSetSetArtist({value, fee, memo}: sendMsgSetSetArtistParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetProfileCard: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSetSetArtist: 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.msgSetProfileCard({value: MsgSetProfileCard.fromPartial(value)})
+                let msg = this.msgSetSetArtist({value: MsgSetSetArtist.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSetProfileCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetSetArtist: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSaveCardContent({value, fee, memo}: sendMsgSaveCardContentParams): Promise<DeliverTxResponse> {
+        async sendMsgReportMatch({value, fee, memo}: sendMsgReportMatchParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSaveCardContent: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgReportMatch: 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.msgSaveCardContent({value: MsgSaveCardContent.fromPartial(value)})
+                let msg = this.msgReportMatch({value: MsgReportMatch.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSaveCardContent: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgReportMatch: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgApointMatchReporter({
-                                             value,
-                                             fee,
-                                             memo
-                                         }: sendMsgApointMatchReporterParams): Promise<DeliverTxResponse> {
+        async sendMsgCreateCouncil({value, fee, memo}: sendMsgCreateCouncilParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgApointMatchReporter: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgCreateCouncil: 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.msgApointMatchReporter({value: MsgApointMatchReporter.fromPartial(value)})
+                let msg = this.msgCreateCouncil({value: MsgCreateCouncil.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgApointMatchReporter: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCreateCouncil: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddStoryToSet({value, fee, memo}: sendMsgAddStoryToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgSaveCardContent({value, fee, memo}: sendMsgSaveCardContentParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddStoryToSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSaveCardContent: 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.msgAddStoryToSet({value: MsgAddStoryToSet.fromPartial(value)})
+                let msg = this.msgSaveCardContent({value: MsgSaveCardContent.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgAddStoryToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSaveCardContent: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRegisterForCouncil({
-                                            value,
-                                            fee,
-                                            memo
-                                        }: sendMsgRegisterForCouncilParams): Promise<DeliverTxResponse> {
+        async sendMsgSetUserBiography({value, fee, memo}: sendMsgSetUserBiographyParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRegisterForCouncil: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSetUserBiography: 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.msgRegisterForCouncil({value: MsgRegisterForCouncil.fromPartial(value)})
+                let msg = this.msgSetUserBiography({value: MsgSetUserBiography.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgRegisterForCouncil: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetUserBiography: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgVoteCard({value, fee, memo}: sendMsgVoteCardParams): Promise<DeliverTxResponse> {
+        async sendMsgAddCardToSet({value, fee, memo}: sendMsgAddCardToSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgVoteCard: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgAddCardToSet: 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.msgVoteCard({value: MsgVoteCard.fromPartial(value)})
+                let msg = this.msgAddCardToSet({value: MsgAddCardToSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgVoteCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddCardToSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddArtwork({value, fee, memo}: sendMsgAddArtworkParams): Promise<DeliverTxResponse> {
+        async sendMsgCreateSet({value, fee, memo}: sendMsgCreateSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddArtwork: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgCreateSet: 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.msgAddArtwork({value: MsgAddArtwork.fromPartial(value)})
+                let msg = this.msgCreateSet({value: MsgCreateSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgAddArtwork: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCreateSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetCardRarity({value, fee, memo}: sendMsgSetCardRarityParams): Promise<DeliverTxResponse> {
+        async sendMsgDisinviteEarlyAccess({
+                                              value,
+                                              fee,
+                                              memo
+                                          }: sendMsgDisinviteEarlyAccessParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetCardRarity: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgDisinviteEarlyAccess: 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.msgSetCardRarity({value: MsgSetCardRarity.fromPartial(value)})
+                let msg = this.msgDisinviteEarlyAccess({value: MsgDisinviteEarlyAccess.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSetCardRarity: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgDisinviteEarlyAccess: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddCardToSet({value, fee, memo}: sendMsgAddCardToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgVoteCard({value, fee, memo}: sendMsgVoteCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddCardToSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgVoteCard: 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.msgAddCardToSet({value: MsgAddCardToSet.fromPartial(value)})
+                let msg = this.msgVoteCard({value: MsgVoteCard.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgAddCardToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgVoteCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgChangeArtist({value, fee, memo}: sendMsgChangeArtistParams): Promise<DeliverTxResponse> {
+        async sendMsgSetUserWebsite({value, fee, memo}: sendMsgSetUserWebsiteParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgChangeArtist: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSetUserWebsite: 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.msgChangeArtist({value: MsgChangeArtist.fromPartial(value)})
+                let msg = this.msgSetUserWebsite({value: MsgSetUserWebsite.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgChangeArtist: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetUserWebsite: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgReportMatch({value, fee, memo}: sendMsgReportMatchParams): Promise<DeliverTxResponse> {
+        async sendMsgSetSetStoryWriter({value, fee, memo}: sendMsgSetSetStoryWriterParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgReportMatch: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSetSetStoryWriter: 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.msgReportMatch({value: MsgReportMatch.fromPartial(value)})
+                let msg = this.msgSetSetStoryWriter({value: MsgSetSetStoryWriter.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgReportMatch: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetSetStoryWriter: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRemoveSellOffer({value, fee, memo}: sendMsgRemoveSellOfferParams): Promise<DeliverTxResponse> {
+        async sendMsgRewokeCouncilRegistration({
+                                                   value,
+                                                   fee,
+                                                   memo
+                                               }: sendMsgRewokeCouncilRegistrationParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRemoveSellOffer: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgRewokeCouncilRegistration: 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.msgRemoveSellOffer({value: MsgRemoveSellOffer.fromPartial(value)})
+                let msg = this.msgRewokeCouncilRegistration({value: MsgRewokeCouncilRegistration.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgRemoveSellOffer: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRewokeCouncilRegistration: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgMultiVoteCard({value, fee, memo}: sendMsgMultiVoteCardParams): Promise<DeliverTxResponse> {
+        async sendMsgCommitCouncilResponse({
+                                               value,
+                                               fee,
+                                               memo
+                                           }: sendMsgCommitCouncilResponseParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgMultiVoteCard: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgCommitCouncilResponse: 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.msgMultiVoteCard({value: MsgMultiVoteCard.fromPartial(value)})
+                let msg = this.msgCommitCouncilResponse({value: MsgCommitCouncilResponse.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgMultiVoteCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCommitCouncilResponse: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgBuyCardScheme({value, fee, memo}: sendMsgBuyCardSchemeParams): Promise<DeliverTxResponse> {
+        async sendMsgBuyBoosterPack({value, fee, memo}: sendMsgBuyBoosterPackParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBuyCardScheme: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgBuyBoosterPack: 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.msgBuyCardScheme({value: MsgBuyCardScheme.fromPartial(value)})
+                let msg = this.msgBuyBoosterPack({value: MsgBuyBoosterPack.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgBuyCardScheme: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgBuyBoosterPack: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgTransferCard({value, fee, memo}: sendMsgTransferCardParams): Promise<DeliverTxResponse> {
+        async sendMsgAddContributorToSet({
+                                             value,
+                                             fee,
+                                             memo
+                                         }: sendMsgAddContributorToSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgTransferCard: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgAddContributorToSet: 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.msgTransferCard({value: MsgTransferCard.fromPartial(value)})
+                let msg = this.msgAddContributorToSet({value: MsgAddContributorToSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgTransferCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddContributorToSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgBuyBoosterPack({value, fee, memo}: sendMsgBuyBoosterPackParams): Promise<DeliverTxResponse> {
+        async sendMsgRegisterForCouncil({
+                                            value,
+                                            fee,
+                                            memo
+                                        }: sendMsgRegisterForCouncilParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBuyBoosterPack: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgRegisterForCouncil: 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.msgBuyBoosterPack({value: MsgBuyBoosterPack.fromPartial(value)})
+                let msg = this.msgRegisterForCouncil({value: MsgRegisterForCouncil.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgBuyBoosterPack: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRegisterForCouncil: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCreateCouncil({value, fee, memo}: sendMsgCreateCouncilParams): Promise<DeliverTxResponse> {
+        async sendMsgOpenMatch({value, fee, memo}: sendMsgOpenMatchParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateCouncil: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgOpenMatch: 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.msgCreateCouncil({value: MsgCreateCouncil.fromPartial(value)})
+                let msg = this.msgOpenMatch({value: MsgOpenMatch.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgCreateCouncil: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgOpenMatch: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgDonateToCard({value, fee, memo}: sendMsgDonateToCardParams): Promise<DeliverTxResponse> {
+        async sendMsgSetProfileCard({value, fee, memo}: sendMsgSetProfileCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgDonateToCard: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSetProfileCard: 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.msgDonateToCard({value: MsgDonateToCard.fromPartial(value)})
+                let msg = this.msgSetProfileCard({value: MsgSetProfileCard.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgDonateToCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetProfileCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddContributorToSet({
-                                             value,
-                                             fee,
-                                             memo
-                                         }: sendMsgAddContributorToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgChangeArtist({value, fee, memo}: sendMsgChangeArtistParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddContributorToSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgChangeArtist: 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.msgAddContributorToSet({value: MsgAddContributorToSet.fromPartial(value)})
+                let msg = this.msgChangeArtist({value: MsgChangeArtist.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgAddContributorToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgChangeArtist: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgOpenBoosterPack({value, fee, memo}: sendMsgOpenBoosterPackParams): Promise<DeliverTxResponse> {
+        async sendMsgDonateToCard({value, fee, memo}: sendMsgDonateToCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgOpenBoosterPack: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgDonateToCard: 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.msgOpenBoosterPack({value: MsgOpenBoosterPack.fromPartial(value)})
+                let msg = this.msgDonateToCard({value: MsgDonateToCard.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgOpenBoosterPack: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgDonateToCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRemoveCardFromSet({value, fee, memo}: sendMsgRemoveCardFromSetParams): Promise<DeliverTxResponse> {
+        async sendMsgBuyCard({value, fee, memo}: sendMsgBuyCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRemoveCardFromSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgBuyCard: 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.msgRemoveCardFromSet({value: MsgRemoveCardFromSet.fromPartial(value)})
+                let msg = this.msgBuyCard({value: MsgBuyCard.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgRemoveCardFromSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgBuyCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetUserBiography({value, fee, memo}: sendMsgSetUserBiographyParams): Promise<DeliverTxResponse> {
+        async sendMsgCreateuser({value, fee, memo}: sendMsgCreateuserParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetUserBiography: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgCreateuser: 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.msgSetUserBiography({value: MsgSetUserBiography.fromPartial(value)})
+                let msg = this.msgCreateuser({value: MsgCreateuser.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSetUserBiography: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCreateuser: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCreateuser({value, fee, memo}: sendMsgCreateuserParams): Promise<DeliverTxResponse> {
+        async sendMsgRemoveCardFromSet({value, fee, memo}: sendMsgRemoveCardFromSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateuser: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgRemoveCardFromSet: 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.msgCreateuser({value: MsgCreateuser.fromPartial(value)})
+                let msg = this.msgRemoveCardFromSet({value: MsgRemoveCardFromSet.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgCreateuser: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRemoveCardFromSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCreateSet({value, fee, memo}: sendMsgCreateSetParams): Promise<DeliverTxResponse> {
+        async sendMsgCreateSellOffer({value, fee, memo}: sendMsgCreateSellOfferParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgCreateSellOffer: 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.msgCreateSet({value: MsgCreateSet.fromPartial(value)})
+                let msg = this.msgCreateSellOffer({value: MsgCreateSellOffer.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgCreateSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCreateSellOffer: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRemoveContributorFromSet({
-                                                  value,
-                                                  fee,
-                                                  memo
-                                              }: sendMsgRemoveContributorFromSetParams): Promise<DeliverTxResponse> {
+        async sendMsgRestartCouncil({value, fee, memo}: sendMsgRestartCouncilParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRemoveContributorFromSet: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgRestartCouncil: 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.msgRemoveContributorFromSet({value: MsgRemoveContributorFromSet.fromPartial(value)})
+                let msg = this.msgRestartCouncil({value: MsgRestartCouncil.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgRemoveContributorFromSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRestartCouncil: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetSetName({value, fee, memo}: sendMsgSetSetNameParams): Promise<DeliverTxResponse> {
+        async sendMsgSetCardRarity({value, fee, memo}: sendMsgSetCardRarityParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetSetName: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgSetCardRarity: 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.msgSetSetName({value: MsgSetSetName.fromPartial(value)})
+                let msg = this.msgSetCardRarity({value: MsgSetCardRarity.fromPartial(value)})
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
             } catch (e: any) {
-                throw new Error('TxClient:sendMsgSetSetName: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetCardRarity: Could not broadcast Tx: ' + e.message)
             }
         },
 
@@ -1227,47 +1227,47 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
         },
 
 
-        msgSetUserWebsite({value}: msgSetUserWebsiteParams): EncodeObject {
+        msgBuyCardScheme({value}: msgBuyCardSchemeParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserWebsite",
-                    value: MsgSetUserWebsite.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCardScheme",
+                    value: MsgBuyCardScheme.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetUserWebsite: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgBuyCardScheme: Could not create message: ' + e.message)
             }
         },
 
-        msgBuyCard({value}: msgBuyCardParams): EncodeObject {
+        msgAddArtwork({value}: msgAddArtworkParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCard",
-                    value: MsgBuyCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddArtwork",
+                    value: MsgAddArtwork.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgBuyCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddArtwork: Could not create message: ' + e.message)
             }
         },
 
-        msgSetSetStoryWriter({value}: msgSetSetStoryWriterParams): EncodeObject {
+        msgSetSetName({value}: msgSetSetNameParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetStoryWriter",
-                    value: MsgSetSetStoryWriter.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetName",
+                    value: MsgSetSetName.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetSetStoryWriter: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetSetName: Could not create message: ' + e.message)
             }
         },
 
-        msgChangeAlias({value}: msgChangeAliasParams): EncodeObject {
+        msgConfirmMatch({value}: msgConfirmMatchParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeAlias",
-                    value: MsgChangeAlias.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgConfirmMatch",
+                    value: MsgConfirmMatch.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgChangeAlias: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgConfirmMatch: Could not create message: ' + e.message)
             }
         },
 
@@ -1282,69 +1282,91 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgRevealCouncilResponse({value}: msgRevealCouncilResponseParams): EncodeObject {
+        msgMultiVoteCard({value}: msgMultiVoteCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRevealCouncilResponse",
-                    value: MsgRevealCouncilResponse.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgMultiVoteCard",
+                    value: MsgMultiVoteCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRevealCouncilResponse: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgMultiVoteCard: Could not create message: ' + e.message)
             }
         },
 
-        msgRewokeCouncilRegistration({value}: msgRewokeCouncilRegistrationParams): EncodeObject {
+        msgFinalizeSet({value}: msgFinalizeSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRewokeCouncilRegistration",
-                    value: MsgRewokeCouncilRegistration.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgFinalizeSet",
+                    value: MsgFinalizeSet.fromPartial(value)
+                }
+            } catch (e: any) {
+                throw new Error('TxClient:MsgFinalizeSet: Could not create message: ' + e.message)
+            }
+        },
+
+        msgOpenBoosterPack({value}: msgOpenBoosterPackParams): EncodeObject {
+            try {
+                return {
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenBoosterPack",
+                    value: MsgOpenBoosterPack.fromPartial(value)
+                }
+            } catch (e: any) {
+                throw new Error('TxClient:MsgOpenBoosterPack: Could not create message: ' + e.message)
+            }
+        },
+
+        msgTransferCard({value}: msgTransferCardParams): EncodeObject {
+            try {
+                return {
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgTransferCard",
+                    value: MsgTransferCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRewokeCouncilRegistration: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgTransferCard: Could not create message: ' + e.message)
             }
         },
 
-        msgRestartCouncil({value}: msgRestartCouncilParams): EncodeObject {
+        msgRemoveContributorFromSet({value}: msgRemoveContributorFromSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRestartCouncil",
-                    value: MsgRestartCouncil.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveContributorFromSet",
+                    value: MsgRemoveContributorFromSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRestartCouncil: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRemoveContributorFromSet: Could not create message: ' + e.message)
             }
         },
 
-        msgSetSetArtist({value}: msgSetSetArtistParams): EncodeObject {
+        msgChangeAlias({value}: msgChangeAliasParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetArtist",
-                    value: MsgSetSetArtist.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeAlias",
+                    value: MsgChangeAlias.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetSetArtist: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgChangeAlias: Could not create message: ' + e.message)
             }
         },
 
-        msgFinalizeSet({value}: msgFinalizeSetParams): EncodeObject {
+        msgRemoveSellOffer({value}: msgRemoveSellOfferParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgFinalizeSet",
-                    value: MsgFinalizeSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveSellOffer",
+                    value: MsgRemoveSellOffer.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgFinalizeSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRemoveSellOffer: Could not create message: ' + e.message)
             }
         },
 
-        msgOpenMatch({value}: msgOpenMatchParams): EncodeObject {
+        msgApointMatchReporter({value}: msgApointMatchReporterParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenMatch",
-                    value: MsgOpenMatch.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgApointMatchReporter",
+                    value: MsgApointMatchReporter.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgOpenMatch: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgApointMatchReporter: Could not create message: ' + e.message)
             }
         },
 
@@ -1359,58 +1381,58 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgConfirmMatch({value}: msgConfirmMatchParams): EncodeObject {
+        msgAddStoryToSet({value}: msgAddStoryToSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgConfirmMatch",
-                    value: MsgConfirmMatch.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddStoryToSet",
+                    value: MsgAddStoryToSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgConfirmMatch: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddStoryToSet: Could not create message: ' + e.message)
             }
         },
 
-        msgCreateSellOffer({value}: msgCreateSellOfferParams): EncodeObject {
+        msgRevealCouncilResponse({value}: msgRevealCouncilResponseParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateSellOffer",
-                    value: MsgCreateSellOffer.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRevealCouncilResponse",
+                    value: MsgRevealCouncilResponse.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgCreateSellOffer: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRevealCouncilResponse: Could not create message: ' + e.message)
             }
         },
 
-        msgDisinviteEarlyAccess({value}: msgDisinviteEarlyAccessParams): EncodeObject {
+        msgSetSetArtist({value}: msgSetSetArtistParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgDisinviteEarlyAccess",
-                    value: MsgDisinviteEarlyAccess.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetArtist",
+                    value: MsgSetSetArtist.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgDisinviteEarlyAccess: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetSetArtist: Could not create message: ' + e.message)
             }
         },
 
-        msgCommitCouncilResponse({value}: msgCommitCouncilResponseParams): EncodeObject {
+        msgReportMatch({value}: msgReportMatchParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCommitCouncilResponse",
-                    value: MsgCommitCouncilResponse.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgReportMatch",
+                    value: MsgReportMatch.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgCommitCouncilResponse: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgReportMatch: Could not create message: ' + e.message)
             }
         },
 
-        msgSetProfileCard({value}: msgSetProfileCardParams): EncodeObject {
+        msgCreateCouncil({value}: msgCreateCouncilParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetProfileCard",
-                    value: MsgSetProfileCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateCouncil",
+                    value: MsgCreateCouncil.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetProfileCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCreateCouncil: Could not create message: ' + e.message)
             }
         },
 
@@ -1425,168 +1447,168 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgApointMatchReporter({value}: msgApointMatchReporterParams): EncodeObject {
+        msgSetUserBiography({value}: msgSetUserBiographyParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgApointMatchReporter",
-                    value: MsgApointMatchReporter.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserBiography",
+                    value: MsgSetUserBiography.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgApointMatchReporter: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetUserBiography: Could not create message: ' + e.message)
             }
         },
 
-        msgAddStoryToSet({value}: msgAddStoryToSetParams): EncodeObject {
+        msgAddCardToSet({value}: msgAddCardToSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddStoryToSet",
-                    value: MsgAddStoryToSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddCardToSet",
+                    value: MsgAddCardToSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddStoryToSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddCardToSet: Could not create message: ' + e.message)
             }
         },
 
-        msgRegisterForCouncil({value}: msgRegisterForCouncilParams): EncodeObject {
+        msgCreateSet({value}: msgCreateSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRegisterForCouncil",
-                    value: MsgRegisterForCouncil.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateSet",
+                    value: MsgCreateSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRegisterForCouncil: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCreateSet: Could not create message: ' + e.message)
             }
         },
 
-        msgVoteCard({value}: msgVoteCardParams): EncodeObject {
+        msgDisinviteEarlyAccess({value}: msgDisinviteEarlyAccessParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgVoteCard",
-                    value: MsgVoteCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgDisinviteEarlyAccess",
+                    value: MsgDisinviteEarlyAccess.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgVoteCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgDisinviteEarlyAccess: Could not create message: ' + e.message)
             }
         },
 
-        msgAddArtwork({value}: msgAddArtworkParams): EncodeObject {
+        msgVoteCard({value}: msgVoteCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddArtwork",
-                    value: MsgAddArtwork.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgVoteCard",
+                    value: MsgVoteCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddArtwork: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgVoteCard: Could not create message: ' + e.message)
             }
         },
 
-        msgSetCardRarity({value}: msgSetCardRarityParams): EncodeObject {
+        msgSetUserWebsite({value}: msgSetUserWebsiteParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetCardRarity",
-                    value: MsgSetCardRarity.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserWebsite",
+                    value: MsgSetUserWebsite.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetCardRarity: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetUserWebsite: Could not create message: ' + e.message)
             }
         },
 
-        msgAddCardToSet({value}: msgAddCardToSetParams): EncodeObject {
+        msgSetSetStoryWriter({value}: msgSetSetStoryWriterParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddCardToSet",
-                    value: MsgAddCardToSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetStoryWriter",
+                    value: MsgSetSetStoryWriter.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddCardToSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetSetStoryWriter: Could not create message: ' + e.message)
             }
         },
 
-        msgChangeArtist({value}: msgChangeArtistParams): EncodeObject {
+        msgRewokeCouncilRegistration({value}: msgRewokeCouncilRegistrationParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeArtist",
-                    value: MsgChangeArtist.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRewokeCouncilRegistration",
+                    value: MsgRewokeCouncilRegistration.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgChangeArtist: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRewokeCouncilRegistration: Could not create message: ' + e.message)
             }
         },
 
-        msgReportMatch({value}: msgReportMatchParams): EncodeObject {
+        msgCommitCouncilResponse({value}: msgCommitCouncilResponseParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgReportMatch",
-                    value: MsgReportMatch.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCommitCouncilResponse",
+                    value: MsgCommitCouncilResponse.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgReportMatch: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCommitCouncilResponse: Could not create message: ' + e.message)
             }
         },
 
-        msgRemoveSellOffer({value}: msgRemoveSellOfferParams): EncodeObject {
+        msgBuyBoosterPack({value}: msgBuyBoosterPackParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveSellOffer",
-                    value: MsgRemoveSellOffer.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyBoosterPack",
+                    value: MsgBuyBoosterPack.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRemoveSellOffer: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgBuyBoosterPack: Could not create message: ' + e.message)
             }
         },
 
-        msgMultiVoteCard({value}: msgMultiVoteCardParams): EncodeObject {
+        msgAddContributorToSet({value}: msgAddContributorToSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgMultiVoteCard",
-                    value: MsgMultiVoteCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddContributorToSet",
+                    value: MsgAddContributorToSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgMultiVoteCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddContributorToSet: Could not create message: ' + e.message)
             }
         },
 
-        msgBuyCardScheme({value}: msgBuyCardSchemeParams): EncodeObject {
+        msgRegisterForCouncil({value}: msgRegisterForCouncilParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCardScheme",
-                    value: MsgBuyCardScheme.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRegisterForCouncil",
+                    value: MsgRegisterForCouncil.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgBuyCardScheme: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRegisterForCouncil: Could not create message: ' + e.message)
             }
         },
 
-        msgTransferCard({value}: msgTransferCardParams): EncodeObject {
+        msgOpenMatch({value}: msgOpenMatchParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgTransferCard",
-                    value: MsgTransferCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenMatch",
+                    value: MsgOpenMatch.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgTransferCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgOpenMatch: Could not create message: ' + e.message)
             }
         },
 
-        msgBuyBoosterPack({value}: msgBuyBoosterPackParams): EncodeObject {
+        msgSetProfileCard({value}: msgSetProfileCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyBoosterPack",
-                    value: MsgBuyBoosterPack.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetProfileCard",
+                    value: MsgSetProfileCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgBuyBoosterPack: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetProfileCard: Could not create message: ' + e.message)
             }
         },
 
-        msgCreateCouncil({value}: msgCreateCouncilParams): EncodeObject {
+        msgChangeArtist({value}: msgChangeArtistParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateCouncil",
-                    value: MsgCreateCouncil.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeArtist",
+                    value: MsgChangeArtist.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgCreateCouncil: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgChangeArtist: Could not create message: ' + e.message)
             }
         },
 
@@ -1601,25 +1623,25 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgAddContributorToSet({value}: msgAddContributorToSetParams): EncodeObject {
+        msgBuyCard({value}: msgBuyCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddContributorToSet",
-                    value: MsgAddContributorToSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCard",
+                    value: MsgBuyCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddContributorToSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgBuyCard: Could not create message: ' + e.message)
             }
         },
 
-        msgOpenBoosterPack({value}: msgOpenBoosterPackParams): EncodeObject {
+        msgCreateuser({value}: msgCreateuserParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenBoosterPack",
-                    value: MsgOpenBoosterPack.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateuser",
+                    value: MsgCreateuser.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgOpenBoosterPack: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCreateuser: Could not create message: ' + e.message)
             }
         },
 
@@ -1634,58 +1656,36 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgSetUserBiography({value}: msgSetUserBiographyParams): EncodeObject {
-            try {
-                return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserBiography",
-                    value: MsgSetUserBiography.fromPartial(value)
-                }
-            } catch (e: any) {
-                throw new Error('TxClient:MsgSetUserBiography: Could not create message: ' + e.message)
-            }
-        },
-
-        msgCreateuser({value}: msgCreateuserParams): EncodeObject {
-            try {
-                return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateuser",
-                    value: MsgCreateuser.fromPartial(value)
-                }
-            } catch (e: any) {
-                throw new Error('TxClient:MsgCreateuser: Could not create message: ' + e.message)
-            }
-        },
-
-        msgCreateSet({value}: msgCreateSetParams): EncodeObject {
+        msgCreateSellOffer({value}: msgCreateSellOfferParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateSet",
-                    value: MsgCreateSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateSellOffer",
+                    value: MsgCreateSellOffer.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgCreateSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCreateSellOffer: Could not create message: ' + e.message)
             }
         },
 
-        msgRemoveContributorFromSet({value}: msgRemoveContributorFromSetParams): EncodeObject {
+        msgRestartCouncil({value}: msgRestartCouncilParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveContributorFromSet",
-                    value: MsgRemoveContributorFromSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRestartCouncil",
+                    value: MsgRestartCouncil.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRemoveContributorFromSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRestartCouncil: Could not create message: ' + e.message)
             }
         },
 
-        msgSetSetName({value}: msgSetSetNameParams): EncodeObject {
+        msgSetCardRarity({value}: msgSetCardRarityParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetName",
-                    value: MsgSetSetName.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetCardRarity",
+                    value: MsgSetCardRarity.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetSetName: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetCardRarity: Could not create message: ' + e.message)
             }
         },