decentralcardgame-cardchain-client-ts 0.0.27 → 0.0.28

package/DecentralCardGame.cardchain.cardchain/module.ts

@@ -7,47 +7,49 @@ import {msgTypes} from './registry';
 import {IgniteClient} from "../client"
 import {MissingWalletError} from "../helpers"
 import {Api} from "./rest";
-import {MsgChangeAlias} from "./types/cardchain/cardchain/tx";
-import {MsgChangeArtist} from "./types/cardchain/cardchain/tx";
-import {MsgAddContributorToSet} from "./types/cardchain/cardchain/tx";
-import {MsgAddArtworkToSet} from "./types/cardchain/cardchain/tx";
-import {MsgBuyCardScheme} from "./types/cardchain/cardchain/tx";
-import {MsgVoteCard} from "./types/cardchain/cardchain/tx";
-import {MsgOpenBoosterPack} from "./types/cardchain/cardchain/tx";
-import {MsgMultiVoteCard} from "./types/cardchain/cardchain/tx";
-import {MsgSetSetArtist} from "./types/cardchain/cardchain/tx";
-import {MsgApointMatchReporter} from "./types/cardchain/cardchain/tx";
-import {MsgAddArtwork} from "./types/cardchain/cardchain/tx";
-import {MsgCreateSellOffer} from "./types/cardchain/cardchain/tx";
+import {MsgSetUserWebsite} from "./types/cardchain/cardchain/tx";
 import {MsgBuyCard} from "./types/cardchain/cardchain/tx";
-import {MsgCreateuser} from "./types/cardchain/cardchain/tx";
-import {MsgBuyBoosterPack} from "./types/cardchain/cardchain/tx";
-import {MsgCreateCouncil} from "./types/cardchain/cardchain/tx";
-import {MsgSetUserBiography} from "./types/cardchain/cardchain/tx";
 import {MsgSetSetStoryWriter} from "./types/cardchain/cardchain/tx";
-import {MsgDonateToCard} from "./types/cardchain/cardchain/tx";
-import {MsgRemoveContributorFromSet} from "./types/cardchain/cardchain/tx";
-import {MsgSetUserWebsite} from "./types/cardchain/cardchain/tx";
-import {MsgTransferCard} from "./types/cardchain/cardchain/tx";
+import {MsgChangeAlias} 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 {MsgFinalizeSet} from "./types/cardchain/cardchain/tx";
 import {MsgOpenMatch} from "./types/cardchain/cardchain/tx";
-import {MsgSetCardRarity} from "./types/cardchain/cardchain/tx";
-import {MsgRegisterForCouncil} 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 {MsgDisinviteEarlyAccess} 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 {MsgRestartCouncil} from "./types/cardchain/cardchain/tx";
+import {MsgApointMatchReporter} from "./types/cardchain/cardchain/tx";
 import {MsgAddStoryToSet} from "./types/cardchain/cardchain/tx";
-import {MsgReportMatch} 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 {MsgRevealCouncilResponse} 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 {MsgSetSetName} from "./types/cardchain/cardchain/tx";
-import {MsgTransferBoosterPack} from "./types/cardchain/cardchain/tx";
+import {MsgSetUserBiography} from "./types/cardchain/cardchain/tx";
+import {MsgCreateuser} from "./types/cardchain/cardchain/tx";
 import {MsgCreateSet} from "./types/cardchain/cardchain/tx";
-import {MsgRemoveSellOffer} from "./types/cardchain/cardchain/tx";
-import {MsgConfirmMatch} from "./types/cardchain/cardchain/tx";
-import {MsgCommitCouncilResponse} from "./types/cardchain/cardchain/tx";
+import {MsgRemoveContributorFromSet} from "./types/cardchain/cardchain/tx";
+import {MsgSetSetName} from "./types/cardchain/cardchain/tx";
+import {MsgInviteEarlyAccess} from "./types/cardchain/cardchain/tx";
 
 import {Card as typeCard} from "./types"
 import {TimeStamp as typeTimeStamp} from "./types"
@@ -67,6 +69,7 @@ import {Set as typeSet} from "./types"
 import {InnerRarities as typeInnerRarities} from "./types"
 import {AddrWithQuantity as typeAddrWithQuantity} from "./types"
 import {SetProposal as typeSetProposal} from "./types"
+import {EarlyAccess as typeEarlyAccess} from "./types"
 import {BoosterPack as typeBoosterPack} from "./types"
 import {AirDrops as typeAirDrops} from "./types"
 import {VotingResults as typeVotingResults} from "./types"
@@ -74,93 +77,95 @@ import {VotingResult as typeVotingResult} from "./types"
 import {SingleVote as typeSingleVote} from "./types"
 
 export {
-    MsgChangeAlias,
-    MsgChangeArtist,
-    MsgAddContributorToSet,
-    MsgAddArtworkToSet,
-    MsgBuyCardScheme,
-    MsgVoteCard,
-    MsgOpenBoosterPack,
-    MsgMultiVoteCard,
-    MsgSetSetArtist,
-    MsgApointMatchReporter,
-    MsgAddArtwork,
-    MsgCreateSellOffer,
+    MsgSetUserWebsite,
     MsgBuyCard,
-    MsgCreateuser,
-    MsgBuyBoosterPack,
-    MsgCreateCouncil,
-    MsgSetUserBiography,
     MsgSetSetStoryWriter,
-    MsgDonateToCard,
-    MsgRemoveContributorFromSet,
-    MsgSetUserWebsite,
-    MsgTransferCard,
+    MsgChangeAlias,
+    MsgTransferBoosterPack,
+    MsgRevealCouncilResponse,
     MsgRewokeCouncilRegistration,
+    MsgRestartCouncil,
+    MsgSetSetArtist,
     MsgFinalizeSet,
     MsgOpenMatch,
-    MsgSetCardRarity,
-    MsgRegisterForCouncil,
+    MsgAddArtworkToSet,
+    MsgConfirmMatch,
+    MsgCreateSellOffer,
+    MsgDisinviteEarlyAccess,
+    MsgCommitCouncilResponse,
+    MsgSetProfileCard,
     MsgSaveCardContent,
-    MsgRestartCouncil,
+    MsgApointMatchReporter,
     MsgAddStoryToSet,
-    MsgReportMatch,
+    MsgRegisterForCouncil,
+    MsgVoteCard,
+    MsgAddArtwork,
+    MsgSetCardRarity,
     MsgAddCardToSet,
-    MsgRevealCouncilResponse,
-    MsgSetProfileCard,
+    MsgChangeArtist,
+    MsgReportMatch,
+    MsgRemoveSellOffer,
+    MsgMultiVoteCard,
+    MsgBuyCardScheme,
+    MsgTransferCard,
+    MsgBuyBoosterPack,
+    MsgCreateCouncil,
+    MsgDonateToCard,
+    MsgAddContributorToSet,
+    MsgOpenBoosterPack,
     MsgRemoveCardFromSet,
-    MsgSetSetName,
-    MsgTransferBoosterPack,
+    MsgSetUserBiography,
+    MsgCreateuser,
     MsgCreateSet,
-    MsgRemoveSellOffer,
-    MsgConfirmMatch,
-    MsgCommitCouncilResponse
+    MsgRemoveContributorFromSet,
+    MsgSetSetName,
+    MsgInviteEarlyAccess
 };
 
-type sendMsgChangeAliasParams = {
-    value: MsgChangeAlias,
+type sendMsgSetUserWebsiteParams = {
+    value: MsgSetUserWebsite,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgChangeArtistParams = {
-    value: MsgChangeArtist,
+type sendMsgBuyCardParams = {
+    value: MsgBuyCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddContributorToSetParams = {
-    value: MsgAddContributorToSet,
+type sendMsgSetSetStoryWriterParams = {
+    value: MsgSetSetStoryWriter,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddArtworkToSetParams = {
-    value: MsgAddArtworkToSet,
+type sendMsgChangeAliasParams = {
+    value: MsgChangeAlias,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgBuyCardSchemeParams = {
-    value: MsgBuyCardScheme,
+type sendMsgTransferBoosterPackParams = {
+    value: MsgTransferBoosterPack,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgVoteCardParams = {
-    value: MsgVoteCard,
+type sendMsgRevealCouncilResponseParams = {
+    value: MsgRevealCouncilResponse,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgOpenBoosterPackParams = {
-    value: MsgOpenBoosterPack,
+type sendMsgRewokeCouncilRegistrationParams = {
+    value: MsgRewokeCouncilRegistration,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgMultiVoteCardParams = {
-    value: MsgMultiVoteCard,
+type sendMsgRestartCouncilParams = {
+    value: MsgRestartCouncil,
     fee?: StdFee,
     memo?: string
 };
@@ -171,14 +176,26 @@ type sendMsgSetSetArtistParams = {
     memo?: string
 };
 
-type sendMsgApointMatchReporterParams = {
-    value: MsgApointMatchReporter,
+type sendMsgFinalizeSetParams = {
+    value: MsgFinalizeSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddArtworkParams = {
-    value: MsgAddArtwork,
+type sendMsgOpenMatchParams = {
+    value: MsgOpenMatch,
+    fee?: StdFee,
+    memo?: string
+};
+
+type sendMsgAddArtworkToSetParams = {
+    value: MsgAddArtworkToSet,
+    fee?: StdFee,
+    memo?: string
+};
+
+type sendMsgConfirmMatchParams = {
+    value: MsgConfirmMatch,
     fee?: StdFee,
     memo?: string
 };
@@ -189,134 +206,134 @@ type sendMsgCreateSellOfferParams = {
     memo?: string
 };
 
-type sendMsgBuyCardParams = {
-    value: MsgBuyCard,
+type sendMsgDisinviteEarlyAccessParams = {
+    value: MsgDisinviteEarlyAccess,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCreateuserParams = {
-    value: MsgCreateuser,
+type sendMsgCommitCouncilResponseParams = {
+    value: MsgCommitCouncilResponse,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgBuyBoosterPackParams = {
-    value: MsgBuyBoosterPack,
+type sendMsgSetProfileCardParams = {
+    value: MsgSetProfileCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCreateCouncilParams = {
-    value: MsgCreateCouncil,
+type sendMsgSaveCardContentParams = {
+    value: MsgSaveCardContent,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetUserBiographyParams = {
-    value: MsgSetUserBiography,
+type sendMsgApointMatchReporterParams = {
+    value: MsgApointMatchReporter,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetSetStoryWriterParams = {
-    value: MsgSetSetStoryWriter,
+type sendMsgAddStoryToSetParams = {
+    value: MsgAddStoryToSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgDonateToCardParams = {
-    value: MsgDonateToCard,
+type sendMsgRegisterForCouncilParams = {
+    value: MsgRegisterForCouncil,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRemoveContributorFromSetParams = {
-    value: MsgRemoveContributorFromSet,
+type sendMsgVoteCardParams = {
+    value: MsgVoteCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetUserWebsiteParams = {
-    value: MsgSetUserWebsite,
+type sendMsgAddArtworkParams = {
+    value: MsgAddArtwork,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgTransferCardParams = {
-    value: MsgTransferCard,
+type sendMsgSetCardRarityParams = {
+    value: MsgSetCardRarity,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRewokeCouncilRegistrationParams = {
-    value: MsgRewokeCouncilRegistration,
+type sendMsgAddCardToSetParams = {
+    value: MsgAddCardToSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgFinalizeSetParams = {
-    value: MsgFinalizeSet,
+type sendMsgChangeArtistParams = {
+    value: MsgChangeArtist,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgOpenMatchParams = {
-    value: MsgOpenMatch,
+type sendMsgReportMatchParams = {
+    value: MsgReportMatch,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetCardRarityParams = {
-    value: MsgSetCardRarity,
+type sendMsgRemoveSellOfferParams = {
+    value: MsgRemoveSellOffer,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRegisterForCouncilParams = {
-    value: MsgRegisterForCouncil,
+type sendMsgMultiVoteCardParams = {
+    value: MsgMultiVoteCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSaveCardContentParams = {
-    value: MsgSaveCardContent,
+type sendMsgBuyCardSchemeParams = {
+    value: MsgBuyCardScheme,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRestartCouncilParams = {
-    value: MsgRestartCouncil,
+type sendMsgTransferCardParams = {
+    value: MsgTransferCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddStoryToSetParams = {
-    value: MsgAddStoryToSet,
+type sendMsgBuyBoosterPackParams = {
+    value: MsgBuyBoosterPack,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgReportMatchParams = {
-    value: MsgReportMatch,
+type sendMsgCreateCouncilParams = {
+    value: MsgCreateCouncil,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgAddCardToSetParams = {
-    value: MsgAddCardToSet,
+type sendMsgDonateToCardParams = {
+    value: MsgDonateToCard,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgRevealCouncilResponseParams = {
-    value: MsgRevealCouncilResponse,
+type sendMsgAddContributorToSetParams = {
+    value: MsgAddContributorToSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgSetProfileCardParams = {
-    value: MsgSetProfileCard,
+type sendMsgOpenBoosterPackParams = {
+    value: MsgOpenBoosterPack,
     fee?: StdFee,
     memo?: string
 };
@@ -327,14 +344,14 @@ type sendMsgRemoveCardFromSetParams = {
     memo?: string
 };
 
-type sendMsgSetSetNameParams = {
-    value: MsgSetSetName,
+type sendMsgSetUserBiographyParams = {
+    value: MsgSetUserBiography,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgTransferBoosterPackParams = {
-    value: MsgTransferBoosterPack,
+type sendMsgCreateuserParams = {
+    value: MsgCreateuser,
     fee?: StdFee,
     memo?: string
 };
@@ -345,187 +362,195 @@ type sendMsgCreateSetParams = {
     memo?: string
 };
 
-type sendMsgRemoveSellOfferParams = {
-    value: MsgRemoveSellOffer,
+type sendMsgRemoveContributorFromSetParams = {
+    value: MsgRemoveContributorFromSet,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgConfirmMatchParams = {
-    value: MsgConfirmMatch,
+type sendMsgSetSetNameParams = {
+    value: MsgSetSetName,
     fee?: StdFee,
     memo?: string
 };
 
-type sendMsgCommitCouncilResponseParams = {
-    value: MsgCommitCouncilResponse,
+type sendMsgInviteEarlyAccessParams = {
+    value: MsgInviteEarlyAccess,
     fee?: StdFee,
     memo?: string
 };
 
 
-type msgChangeAliasParams = {
-    value: MsgChangeAlias,
+type msgSetUserWebsiteParams = {
+    value: MsgSetUserWebsite,
 };
 
-type msgChangeArtistParams = {
-    value: MsgChangeArtist,
+type msgBuyCardParams = {
+    value: MsgBuyCard,
 };
 
-type msgAddContributorToSetParams = {
-    value: MsgAddContributorToSet,
+type msgSetSetStoryWriterParams = {
+    value: MsgSetSetStoryWriter,
 };
 
-type msgAddArtworkToSetParams = {
-    value: MsgAddArtworkToSet,
+type msgChangeAliasParams = {
+    value: MsgChangeAlias,
 };
 
-type msgBuyCardSchemeParams = {
-    value: MsgBuyCardScheme,
+type msgTransferBoosterPackParams = {
+    value: MsgTransferBoosterPack,
 };
 
-type msgVoteCardParams = {
-    value: MsgVoteCard,
+type msgRevealCouncilResponseParams = {
+    value: MsgRevealCouncilResponse,
 };
 
-type msgOpenBoosterPackParams = {
-    value: MsgOpenBoosterPack,
+type msgRewokeCouncilRegistrationParams = {
+    value: MsgRewokeCouncilRegistration,
 };
 
-type msgMultiVoteCardParams = {
-    value: MsgMultiVoteCard,
+type msgRestartCouncilParams = {
+    value: MsgRestartCouncil,
 };
 
 type msgSetSetArtistParams = {
     value: MsgSetSetArtist,
 };
 
-type msgApointMatchReporterParams = {
-    value: MsgApointMatchReporter,
+type msgFinalizeSetParams = {
+    value: MsgFinalizeSet,
 };
 
-type msgAddArtworkParams = {
-    value: MsgAddArtwork,
+type msgOpenMatchParams = {
+    value: MsgOpenMatch,
+};
+
+type msgAddArtworkToSetParams = {
+    value: MsgAddArtworkToSet,
+};
+
+type msgConfirmMatchParams = {
+    value: MsgConfirmMatch,
 };
 
 type msgCreateSellOfferParams = {
     value: MsgCreateSellOffer,
 };
 
-type msgBuyCardParams = {
-    value: MsgBuyCard,
+type msgDisinviteEarlyAccessParams = {
+    value: MsgDisinviteEarlyAccess,
 };
 
-type msgCreateuserParams = {
-    value: MsgCreateuser,
+type msgCommitCouncilResponseParams = {
+    value: MsgCommitCouncilResponse,
 };
 
-type msgBuyBoosterPackParams = {
-    value: MsgBuyBoosterPack,
+type msgSetProfileCardParams = {
+    value: MsgSetProfileCard,
 };
 
-type msgCreateCouncilParams = {
-    value: MsgCreateCouncil,
+type msgSaveCardContentParams = {
+    value: MsgSaveCardContent,
 };
 
-type msgSetUserBiographyParams = {
-    value: MsgSetUserBiography,
+type msgApointMatchReporterParams = {
+    value: MsgApointMatchReporter,
 };
 
-type msgSetSetStoryWriterParams = {
-    value: MsgSetSetStoryWriter,
+type msgAddStoryToSetParams = {
+    value: MsgAddStoryToSet,
 };
 
-type msgDonateToCardParams = {
-    value: MsgDonateToCard,
+type msgRegisterForCouncilParams = {
+    value: MsgRegisterForCouncil,
 };
 
-type msgRemoveContributorFromSetParams = {
-    value: MsgRemoveContributorFromSet,
+type msgVoteCardParams = {
+    value: MsgVoteCard,
 };
 
-type msgSetUserWebsiteParams = {
-    value: MsgSetUserWebsite,
+type msgAddArtworkParams = {
+    value: MsgAddArtwork,
 };
 
-type msgTransferCardParams = {
-    value: MsgTransferCard,
+type msgSetCardRarityParams = {
+    value: MsgSetCardRarity,
 };
 
-type msgRewokeCouncilRegistrationParams = {
-    value: MsgRewokeCouncilRegistration,
+type msgAddCardToSetParams = {
+    value: MsgAddCardToSet,
 };
 
-type msgFinalizeSetParams = {
-    value: MsgFinalizeSet,
+type msgChangeArtistParams = {
+    value: MsgChangeArtist,
 };
 
-type msgOpenMatchParams = {
-    value: MsgOpenMatch,
+type msgReportMatchParams = {
+    value: MsgReportMatch,
 };
 
-type msgSetCardRarityParams = {
-    value: MsgSetCardRarity,
+type msgRemoveSellOfferParams = {
+    value: MsgRemoveSellOffer,
 };
 
-type msgRegisterForCouncilParams = {
-    value: MsgRegisterForCouncil,
+type msgMultiVoteCardParams = {
+    value: MsgMultiVoteCard,
 };
 
-type msgSaveCardContentParams = {
-    value: MsgSaveCardContent,
+type msgBuyCardSchemeParams = {
+    value: MsgBuyCardScheme,
 };
 
-type msgRestartCouncilParams = {
-    value: MsgRestartCouncil,
+type msgTransferCardParams = {
+    value: MsgTransferCard,
 };
 
-type msgAddStoryToSetParams = {
-    value: MsgAddStoryToSet,
+type msgBuyBoosterPackParams = {
+    value: MsgBuyBoosterPack,
 };
 
-type msgReportMatchParams = {
-    value: MsgReportMatch,
+type msgCreateCouncilParams = {
+    value: MsgCreateCouncil,
 };
 
-type msgAddCardToSetParams = {
-    value: MsgAddCardToSet,
+type msgDonateToCardParams = {
+    value: MsgDonateToCard,
 };
 
-type msgRevealCouncilResponseParams = {
-    value: MsgRevealCouncilResponse,
+type msgAddContributorToSetParams = {
+    value: MsgAddContributorToSet,
 };
 
-type msgSetProfileCardParams = {
-    value: MsgSetProfileCard,
+type msgOpenBoosterPackParams = {
+    value: MsgOpenBoosterPack,
 };
 
 type msgRemoveCardFromSetParams = {
     value: MsgRemoveCardFromSet,
 };
 
-type msgSetSetNameParams = {
-    value: MsgSetSetName,
+type msgSetUserBiographyParams = {
+    value: MsgSetUserBiography,
 };
 
-type msgTransferBoosterPackParams = {
-    value: MsgTransferBoosterPack,
+type msgCreateuserParams = {
+    value: MsgCreateuser,
 };
 
 type msgCreateSetParams = {
     value: MsgCreateSet,
 };
 
-type msgRemoveSellOfferParams = {
-    value: MsgRemoveSellOffer,
+type msgRemoveContributorFromSetParams = {
+    value: MsgRemoveContributorFromSet,
 };
 
-type msgConfirmMatchParams = {
-    value: MsgConfirmMatch,
+type msgSetSetNameParams = {
+    value: MsgSetSetName,
 };
 
-type msgCommitCouncilResponseParams = {
-    value: MsgCommitCouncilResponse,
+type msgInviteEarlyAccessParams = {
+    value: MsgInviteEarlyAccess,
 };
 
 
@@ -563,119 +588,127 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
 
     return {
 
-        async sendMsgChangeAlias({value, fee, memo}: sendMsgChangeAliasParams): Promise<DeliverTxResponse> {
+        async sendMsgSetUserWebsite({value, fee, memo}: sendMsgSetUserWebsiteParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgChangeAlias: 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.msgChangeAlias({value: MsgChangeAlias.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:sendMsgChangeAlias: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetUserWebsite: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgChangeArtist({value, fee, memo}: sendMsgChangeArtistParams): Promise<DeliverTxResponse> {
+        async sendMsgBuyCard({value, fee, memo}: sendMsgBuyCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgChangeArtist: 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.msgChangeArtist({value: MsgChangeArtist.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:sendMsgChangeArtist: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgBuyCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddContributorToSet({
-                                             value,
-                                             fee,
-                                             memo
-                                         }: sendMsgAddContributorToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgSetSetStoryWriter({value, fee, memo}: sendMsgSetSetStoryWriterParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddContributorToSet: 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.msgAddContributorToSet({value: MsgAddContributorToSet.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:sendMsgAddContributorToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetSetStoryWriter: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddArtworkToSet({value, fee, memo}: sendMsgAddArtworkToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgChangeAlias({value, fee, memo}: sendMsgChangeAliasParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddArtworkToSet: 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.msgAddArtworkToSet({value: MsgAddArtworkToSet.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:sendMsgAddArtworkToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgChangeAlias: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgBuyCardScheme({value, fee, memo}: sendMsgBuyCardSchemeParams): Promise<DeliverTxResponse> {
+        async sendMsgTransferBoosterPack({
+                                             value,
+                                             fee,
+                                             memo
+                                         }: sendMsgTransferBoosterPackParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBuyCardScheme: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgTransferBoosterPack: 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.msgTransferBoosterPack({value: MsgTransferBoosterPack.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:sendMsgTransferBoosterPack: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgVoteCard({value, fee, memo}: sendMsgVoteCardParams): Promise<DeliverTxResponse> {
+        async sendMsgRevealCouncilResponse({
+                                               value,
+                                               fee,
+                                               memo
+                                           }: sendMsgRevealCouncilResponseParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgVoteCard: 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.msgVoteCard({value: MsgVoteCard.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:sendMsgVoteCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRevealCouncilResponse: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgOpenBoosterPack({value, fee, memo}: sendMsgOpenBoosterPackParams): Promise<DeliverTxResponse> {
+        async sendMsgRewokeCouncilRegistration({
+                                                   value,
+                                                   fee,
+                                                   memo
+                                               }: sendMsgRewokeCouncilRegistrationParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgOpenBoosterPack: 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.msgOpenBoosterPack({value: MsgOpenBoosterPack.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:sendMsgOpenBoosterPack: 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 sendMsgRestartCouncil({value, fee, memo}: sendMsgRestartCouncilParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgMultiVoteCard: 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.msgMultiVoteCard({value: MsgMultiVoteCard.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:sendMsgMultiVoteCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRestartCouncil: Could not broadcast Tx: ' + e.message)
             }
         },
 
@@ -693,35 +726,59 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        async sendMsgApointMatchReporter({
-                                             value,
-                                             fee,
-                                             memo
-                                         }: sendMsgApointMatchReporterParams): Promise<DeliverTxResponse> {
+        async sendMsgFinalizeSet({value, fee, memo}: sendMsgFinalizeSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgApointMatchReporter: 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.msgApointMatchReporter({value: MsgApointMatchReporter.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:sendMsgApointMatchReporter: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgFinalizeSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddArtwork({value, fee, memo}: sendMsgAddArtworkParams): Promise<DeliverTxResponse> {
+        async sendMsgOpenMatch({value, fee, memo}: sendMsgOpenMatchParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddArtwork: 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.msgAddArtwork({value: MsgAddArtwork.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:sendMsgAddArtwork: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgOpenMatch: Could not broadcast Tx: ' + e.message)
+            }
+        },
+
+        async sendMsgAddArtworkToSet({value, fee, memo}: sendMsgAddArtworkToSetParams): Promise<DeliverTxResponse> {
+            if (!signer) {
+                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.msgAddArtworkToSet({value: MsgAddArtworkToSet.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)
+            }
+        },
+
+        async sendMsgConfirmMatch({value, fee, memo}: sendMsgConfirmMatchParams): Promise<DeliverTxResponse> {
+            if (!signer) {
+                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.msgConfirmMatch({value: MsgConfirmMatch.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)
             }
         },
 
@@ -739,327 +796,331 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        async sendMsgBuyCard({value, fee, memo}: sendMsgBuyCardParams): Promise<DeliverTxResponse> {
+        async sendMsgDisinviteEarlyAccess({
+                                              value,
+                                              fee,
+                                              memo
+                                          }: sendMsgDisinviteEarlyAccessParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBuyCard: 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.msgBuyCard({value: MsgBuyCard.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:sendMsgBuyCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgDisinviteEarlyAccess: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCreateuser({value, fee, memo}: sendMsgCreateuserParams): Promise<DeliverTxResponse> {
+        async sendMsgCommitCouncilResponse({
+                                               value,
+                                               fee,
+                                               memo
+                                           }: sendMsgCommitCouncilResponseParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateuser: 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.msgCreateuser({value: MsgCreateuser.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:sendMsgCreateuser: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCommitCouncilResponse: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgBuyBoosterPack({value, fee, memo}: sendMsgBuyBoosterPackParams): Promise<DeliverTxResponse> {
+        async sendMsgSetProfileCard({value, fee, memo}: sendMsgSetProfileCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBuyBoosterPack: 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.msgBuyBoosterPack({value: MsgBuyBoosterPack.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:sendMsgBuyBoosterPack: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetProfileCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCreateCouncil({value, fee, memo}: sendMsgCreateCouncilParams): Promise<DeliverTxResponse> {
+        async sendMsgSaveCardContent({value, fee, memo}: sendMsgSaveCardContentParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateCouncil: 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.msgCreateCouncil({value: MsgCreateCouncil.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:sendMsgCreateCouncil: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSaveCardContent: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetUserBiography({value, fee, memo}: sendMsgSetUserBiographyParams): Promise<DeliverTxResponse> {
+        async sendMsgApointMatchReporter({
+                                             value,
+                                             fee,
+                                             memo
+                                         }: sendMsgApointMatchReporterParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetUserBiography: 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.msgSetUserBiography({value: MsgSetUserBiography.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:sendMsgSetUserBiography: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgApointMatchReporter: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetSetStoryWriter({value, fee, memo}: sendMsgSetSetStoryWriterParams): Promise<DeliverTxResponse> {
+        async sendMsgAddStoryToSet({value, fee, memo}: sendMsgAddStoryToSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetSetStoryWriter: 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.msgSetSetStoryWriter({value: MsgSetSetStoryWriter.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:sendMsgSetSetStoryWriter: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddStoryToSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgDonateToCard({value, fee, memo}: sendMsgDonateToCardParams): Promise<DeliverTxResponse> {
+        async sendMsgRegisterForCouncil({
+                                            value,
+                                            fee,
+                                            memo
+                                        }: sendMsgRegisterForCouncilParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgDonateToCard: 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.msgDonateToCard({value: MsgDonateToCard.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:sendMsgDonateToCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRegisterForCouncil: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRemoveContributorFromSet({
-                                                  value,
-                                                  fee,
-                                                  memo
-                                              }: sendMsgRemoveContributorFromSetParams): Promise<DeliverTxResponse> {
+        async sendMsgVoteCard({value, fee, memo}: sendMsgVoteCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRemoveContributorFromSet: 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.msgRemoveContributorFromSet({value: MsgRemoveContributorFromSet.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:sendMsgRemoveContributorFromSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgVoteCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetUserWebsite({value, fee, memo}: sendMsgSetUserWebsiteParams): Promise<DeliverTxResponse> {
+        async sendMsgAddArtwork({value, fee, memo}: sendMsgAddArtworkParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetUserWebsite: 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.msgSetUserWebsite({value: MsgSetUserWebsite.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:sendMsgSetUserWebsite: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddArtwork: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgTransferCard({value, fee, memo}: sendMsgTransferCardParams): Promise<DeliverTxResponse> {
+        async sendMsgSetCardRarity({value, fee, memo}: sendMsgSetCardRarityParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgTransferCard: 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.msgTransferCard({value: MsgTransferCard.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:sendMsgTransferCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetCardRarity: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRewokeCouncilRegistration({
-                                                   value,
-                                                   fee,
-                                                   memo
-                                               }: sendMsgRewokeCouncilRegistrationParams): Promise<DeliverTxResponse> {
+        async sendMsgAddCardToSet({value, fee, memo}: sendMsgAddCardToSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRewokeCouncilRegistration: 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.msgRewokeCouncilRegistration({value: MsgRewokeCouncilRegistration.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:sendMsgRewokeCouncilRegistration: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddCardToSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgFinalizeSet({value, fee, memo}: sendMsgFinalizeSetParams): Promise<DeliverTxResponse> {
+        async sendMsgChangeArtist({value, fee, memo}: sendMsgChangeArtistParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgFinalizeSet: 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.msgFinalizeSet({value: MsgFinalizeSet.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:sendMsgFinalizeSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgChangeArtist: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgOpenMatch({value, fee, memo}: sendMsgOpenMatchParams): Promise<DeliverTxResponse> {
+        async sendMsgReportMatch({value, fee, memo}: sendMsgReportMatchParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgOpenMatch: 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.msgOpenMatch({value: MsgOpenMatch.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:sendMsgOpenMatch: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgReportMatch: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetCardRarity({value, fee, memo}: sendMsgSetCardRarityParams): Promise<DeliverTxResponse> {
+        async sendMsgRemoveSellOffer({value, fee, memo}: sendMsgRemoveSellOfferParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetCardRarity: 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.msgSetCardRarity({value: MsgSetCardRarity.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:sendMsgSetCardRarity: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRemoveSellOffer: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRegisterForCouncil({
-                                            value,
-                                            fee,
-                                            memo
-                                        }: sendMsgRegisterForCouncilParams): Promise<DeliverTxResponse> {
+        async sendMsgMultiVoteCard({value, fee, memo}: sendMsgMultiVoteCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRegisterForCouncil: 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.msgRegisterForCouncil({value: MsgRegisterForCouncil.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:sendMsgRegisterForCouncil: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgMultiVoteCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSaveCardContent({value, fee, memo}: sendMsgSaveCardContentParams): Promise<DeliverTxResponse> {
+        async sendMsgBuyCardScheme({value, fee, memo}: sendMsgBuyCardSchemeParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSaveCardContent: 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.msgSaveCardContent({value: MsgSaveCardContent.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:sendMsgSaveCardContent: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgBuyCardScheme: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRestartCouncil({value, fee, memo}: sendMsgRestartCouncilParams): Promise<DeliverTxResponse> {
+        async sendMsgTransferCard({value, fee, memo}: sendMsgTransferCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRestartCouncil: 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.msgRestartCouncil({value: MsgRestartCouncil.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:sendMsgRestartCouncil: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgTransferCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddStoryToSet({value, fee, memo}: sendMsgAddStoryToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgBuyBoosterPack({value, fee, memo}: sendMsgBuyBoosterPackParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddStoryToSet: 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.msgAddStoryToSet({value: MsgAddStoryToSet.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:sendMsgAddStoryToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgBuyBoosterPack: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgReportMatch({value, fee, memo}: sendMsgReportMatchParams): Promise<DeliverTxResponse> {
+        async sendMsgCreateCouncil({value, fee, memo}: sendMsgCreateCouncilParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgReportMatch: 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.msgReportMatch({value: MsgReportMatch.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:sendMsgReportMatch: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCreateCouncil: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgAddCardToSet({value, fee, memo}: sendMsgAddCardToSetParams): Promise<DeliverTxResponse> {
+        async sendMsgDonateToCard({value, fee, memo}: sendMsgDonateToCardParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgAddCardToSet: 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.msgAddCardToSet({value: MsgAddCardToSet.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:sendMsgAddCardToSet: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgDonateToCard: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgRevealCouncilResponse({
-                                               value,
-                                               fee,
-                                               memo
-                                           }: sendMsgRevealCouncilResponseParams): Promise<DeliverTxResponse> {
+        async sendMsgAddContributorToSet({
+                                             value,
+                                             fee,
+                                             memo
+                                         }: sendMsgAddContributorToSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRevealCouncilResponse: 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.msgRevealCouncilResponse({value: MsgRevealCouncilResponse.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:sendMsgRevealCouncilResponse: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgAddContributorToSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgSetProfileCard({value, fee, memo}: sendMsgSetProfileCardParams): Promise<DeliverTxResponse> {
+        async sendMsgOpenBoosterPack({value, fee, memo}: sendMsgOpenBoosterPackParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetProfileCard: 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.msgSetProfileCard({value: MsgSetProfileCard.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:sendMsgSetProfileCard: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgOpenBoosterPack: Could not broadcast Tx: ' + e.message)
             }
         },
 
@@ -1077,35 +1138,31 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        async sendMsgSetSetName({value, fee, memo}: sendMsgSetSetNameParams): Promise<DeliverTxResponse> {
+        async sendMsgSetUserBiography({value, fee, memo}: sendMsgSetUserBiographyParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgSetSetName: 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.msgSetSetName({value: MsgSetSetName.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:sendMsgSetSetName: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetUserBiography: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgTransferBoosterPack({
-                                             value,
-                                             fee,
-                                             memo
-                                         }: sendMsgTransferBoosterPackParams): Promise<DeliverTxResponse> {
+        async sendMsgCreateuser({value, fee, memo}: sendMsgCreateuserParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgTransferBoosterPack: 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.msgTransferBoosterPack({value: MsgTransferBoosterPack.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:sendMsgTransferBoosterPack: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgCreateuser: Could not broadcast Tx: ' + e.message)
             }
         },
 
@@ -1123,171 +1180,193 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        async sendMsgRemoveSellOffer({value, fee, memo}: sendMsgRemoveSellOfferParams): Promise<DeliverTxResponse> {
+        async sendMsgRemoveContributorFromSet({
+                                                  value,
+                                                  fee,
+                                                  memo
+                                              }: sendMsgRemoveContributorFromSetParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgRemoveSellOffer: 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.msgRemoveSellOffer({value: MsgRemoveSellOffer.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:sendMsgRemoveSellOffer: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgRemoveContributorFromSet: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgConfirmMatch({value, fee, memo}: sendMsgConfirmMatchParams): Promise<DeliverTxResponse> {
+        async sendMsgSetSetName({value, fee, memo}: sendMsgSetSetNameParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgConfirmMatch: 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.msgConfirmMatch({value: MsgConfirmMatch.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:sendMsgConfirmMatch: Could not broadcast Tx: ' + e.message)
+                throw new Error('TxClient:sendMsgSetSetName: Could not broadcast Tx: ' + e.message)
             }
         },
 
-        async sendMsgCommitCouncilResponse({
-                                               value,
-                                               fee,
-                                               memo
-                                           }: sendMsgCommitCouncilResponseParams): Promise<DeliverTxResponse> {
+        async sendMsgInviteEarlyAccess({value, fee, memo}: sendMsgInviteEarlyAccessParams): Promise<DeliverTxResponse> {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCommitCouncilResponse: Unable to sign Tx. Signer is not present.')
+                throw new Error('TxClient:sendMsgInviteEarlyAccess: 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.msgInviteEarlyAccess({value: MsgInviteEarlyAccess.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:sendMsgInviteEarlyAccess: Could not broadcast Tx: ' + e.message)
             }
         },
 
 
-        msgChangeAlias({value}: msgChangeAliasParams): EncodeObject {
+        msgSetUserWebsite({value}: msgSetUserWebsiteParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeAlias",
-                    value: MsgChangeAlias.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserWebsite",
+                    value: MsgSetUserWebsite.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgChangeAlias: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetUserWebsite: Could not create message: ' + e.message)
             }
         },
 
-        msgChangeArtist({value}: msgChangeArtistParams): EncodeObject {
+        msgBuyCard({value}: msgBuyCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeArtist",
-                    value: MsgChangeArtist.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCard",
+                    value: MsgBuyCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgChangeArtist: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgBuyCard: Could not create message: ' + e.message)
             }
         },
 
-        msgAddContributorToSet({value}: msgAddContributorToSetParams): EncodeObject {
+        msgSetSetStoryWriter({value}: msgSetSetStoryWriterParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddContributorToSet",
-                    value: MsgAddContributorToSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetStoryWriter",
+                    value: MsgSetSetStoryWriter.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddContributorToSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetSetStoryWriter: Could not create message: ' + e.message)
             }
         },
 
-        msgAddArtworkToSet({value}: msgAddArtworkToSetParams): EncodeObject {
+        msgChangeAlias({value}: msgChangeAliasParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddArtworkToSet",
-                    value: MsgAddArtworkToSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeAlias",
+                    value: MsgChangeAlias.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddArtworkToSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgChangeAlias: Could not create message: ' + e.message)
             }
         },
 
-        msgBuyCardScheme({value}: msgBuyCardSchemeParams): EncodeObject {
+        msgTransferBoosterPack({value}: msgTransferBoosterPackParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCardScheme",
-                    value: MsgBuyCardScheme.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgTransferBoosterPack",
+                    value: MsgTransferBoosterPack.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgBuyCardScheme: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgTransferBoosterPack: Could not create message: ' + e.message)
+            }
+        },
+
+        msgRevealCouncilResponse({value}: msgRevealCouncilResponseParams): EncodeObject {
+            try {
+                return {
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRevealCouncilResponse",
+                    value: MsgRevealCouncilResponse.fromPartial(value)
+                }
+            } catch (e: any) {
+                throw new Error('TxClient:MsgRevealCouncilResponse: Could not create message: ' + e.message)
+            }
+        },
+
+        msgRewokeCouncilRegistration({value}: msgRewokeCouncilRegistrationParams): EncodeObject {
+            try {
+                return {
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRewokeCouncilRegistration",
+                    value: MsgRewokeCouncilRegistration.fromPartial(value)
+                }
+            } catch (e: any) {
+                throw new Error('TxClient:MsgRewokeCouncilRegistration: Could not create message: ' + e.message)
             }
         },
 
-        msgVoteCard({value}: msgVoteCardParams): EncodeObject {
+        msgRestartCouncil({value}: msgRestartCouncilParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgVoteCard",
-                    value: MsgVoteCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRestartCouncil",
+                    value: MsgRestartCouncil.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgVoteCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRestartCouncil: Could not create message: ' + e.message)
             }
         },
 
-        msgOpenBoosterPack({value}: msgOpenBoosterPackParams): EncodeObject {
+        msgSetSetArtist({value}: msgSetSetArtistParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenBoosterPack",
-                    value: MsgOpenBoosterPack.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetArtist",
+                    value: MsgSetSetArtist.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgOpenBoosterPack: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetSetArtist: Could not create message: ' + e.message)
             }
         },
 
-        msgMultiVoteCard({value}: msgMultiVoteCardParams): EncodeObject {
+        msgFinalizeSet({value}: msgFinalizeSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgMultiVoteCard",
-                    value: MsgMultiVoteCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgFinalizeSet",
+                    value: MsgFinalizeSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgMultiVoteCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgFinalizeSet: Could not create message: ' + e.message)
             }
         },
 
-        msgSetSetArtist({value}: msgSetSetArtistParams): EncodeObject {
+        msgOpenMatch({value}: msgOpenMatchParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetArtist",
-                    value: MsgSetSetArtist.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenMatch",
+                    value: MsgOpenMatch.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetSetArtist: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgOpenMatch: Could not create message: ' + e.message)
             }
         },
 
-        msgApointMatchReporter({value}: msgApointMatchReporterParams): EncodeObject {
+        msgAddArtworkToSet({value}: msgAddArtworkToSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgApointMatchReporter",
-                    value: MsgApointMatchReporter.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddArtworkToSet",
+                    value: MsgAddArtworkToSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgApointMatchReporter: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddArtworkToSet: Could not create message: ' + e.message)
             }
         },
 
-        msgAddArtwork({value}: msgAddArtworkParams): EncodeObject {
+        msgConfirmMatch({value}: msgConfirmMatchParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddArtwork",
-                    value: MsgAddArtwork.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgConfirmMatch",
+                    value: MsgConfirmMatch.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddArtwork: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgConfirmMatch: Could not create message: ' + e.message)
             }
         },
 
@@ -1302,245 +1381,245 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgBuyCard({value}: msgBuyCardParams): EncodeObject {
+        msgDisinviteEarlyAccess({value}: msgDisinviteEarlyAccessParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCard",
-                    value: MsgBuyCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgDisinviteEarlyAccess",
+                    value: MsgDisinviteEarlyAccess.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgBuyCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgDisinviteEarlyAccess: Could not create message: ' + e.message)
             }
         },
 
-        msgCreateuser({value}: msgCreateuserParams): EncodeObject {
+        msgCommitCouncilResponse({value}: msgCommitCouncilResponseParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateuser",
-                    value: MsgCreateuser.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCommitCouncilResponse",
+                    value: MsgCommitCouncilResponse.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgCreateuser: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCommitCouncilResponse: 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 {
+        msgSaveCardContent({value}: msgSaveCardContentParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateCouncil",
-                    value: MsgCreateCouncil.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSaveCardContent",
+                    value: MsgSaveCardContent.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgCreateCouncil: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSaveCardContent: Could not create message: ' + e.message)
             }
         },
 
-        msgSetUserBiography({value}: msgSetUserBiographyParams): EncodeObject {
+        msgApointMatchReporter({value}: msgApointMatchReporterParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserBiography",
-                    value: MsgSetUserBiography.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgApointMatchReporter",
+                    value: MsgApointMatchReporter.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetUserBiography: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgApointMatchReporter: Could not create message: ' + e.message)
             }
         },
 
-        msgSetSetStoryWriter({value}: msgSetSetStoryWriterParams): EncodeObject {
+        msgAddStoryToSet({value}: msgAddStoryToSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetStoryWriter",
-                    value: MsgSetSetStoryWriter.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddStoryToSet",
+                    value: MsgAddStoryToSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetSetStoryWriter: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddStoryToSet: Could not create message: ' + e.message)
             }
         },
 
-        msgDonateToCard({value}: msgDonateToCardParams): EncodeObject {
+        msgRegisterForCouncil({value}: msgRegisterForCouncilParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgDonateToCard",
-                    value: MsgDonateToCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRegisterForCouncil",
+                    value: MsgRegisterForCouncil.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgDonateToCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRegisterForCouncil: Could not create message: ' + e.message)
             }
         },
 
-        msgRemoveContributorFromSet({value}: msgRemoveContributorFromSetParams): EncodeObject {
+        msgVoteCard({value}: msgVoteCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveContributorFromSet",
-                    value: MsgRemoveContributorFromSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgVoteCard",
+                    value: MsgVoteCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRemoveContributorFromSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgVoteCard: Could not create message: ' + e.message)
             }
         },
 
-        msgSetUserWebsite({value}: msgSetUserWebsiteParams): EncodeObject {
+        msgAddArtwork({value}: msgAddArtworkParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserWebsite",
-                    value: MsgSetUserWebsite.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddArtwork",
+                    value: MsgAddArtwork.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetUserWebsite: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddArtwork: Could not create message: ' + e.message)
             }
         },
 
-        msgTransferCard({value}: msgTransferCardParams): EncodeObject {
+        msgSetCardRarity({value}: msgSetCardRarityParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgTransferCard",
-                    value: MsgTransferCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetCardRarity",
+                    value: MsgSetCardRarity.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgTransferCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetCardRarity: Could not create message: ' + e.message)
             }
         },
 
-        msgRewokeCouncilRegistration({value}: msgRewokeCouncilRegistrationParams): EncodeObject {
+        msgAddCardToSet({value}: msgAddCardToSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRewokeCouncilRegistration",
-                    value: MsgRewokeCouncilRegistration.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddCardToSet",
+                    value: MsgAddCardToSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRewokeCouncilRegistration: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddCardToSet: Could not create message: ' + e.message)
             }
         },
 
-        msgFinalizeSet({value}: msgFinalizeSetParams): EncodeObject {
+        msgChangeArtist({value}: msgChangeArtistParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgFinalizeSet",
-                    value: MsgFinalizeSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgChangeArtist",
+                    value: MsgChangeArtist.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgFinalizeSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgChangeArtist: Could not create message: ' + e.message)
             }
         },
 
-        msgOpenMatch({value}: msgOpenMatchParams): EncodeObject {
+        msgReportMatch({value}: msgReportMatchParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenMatch",
-                    value: MsgOpenMatch.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgReportMatch",
+                    value: MsgReportMatch.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgOpenMatch: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgReportMatch: Could not create message: ' + e.message)
             }
         },
 
-        msgSetCardRarity({value}: msgSetCardRarityParams): EncodeObject {
+        msgRemoveSellOffer({value}: msgRemoveSellOfferParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetCardRarity",
-                    value: MsgSetCardRarity.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveSellOffer",
+                    value: MsgRemoveSellOffer.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetCardRarity: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRemoveSellOffer: Could not create message: ' + e.message)
             }
         },
 
-        msgRegisterForCouncil({value}: msgRegisterForCouncilParams): EncodeObject {
+        msgMultiVoteCard({value}: msgMultiVoteCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRegisterForCouncil",
-                    value: MsgRegisterForCouncil.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgMultiVoteCard",
+                    value: MsgMultiVoteCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRegisterForCouncil: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgMultiVoteCard: Could not create message: ' + e.message)
             }
         },
 
-        msgSaveCardContent({value}: msgSaveCardContentParams): EncodeObject {
+        msgBuyCardScheme({value}: msgBuyCardSchemeParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSaveCardContent",
-                    value: MsgSaveCardContent.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyCardScheme",
+                    value: MsgBuyCardScheme.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSaveCardContent: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgBuyCardScheme: Could not create message: ' + e.message)
             }
         },
 
-        msgRestartCouncil({value}: msgRestartCouncilParams): EncodeObject {
+        msgTransferCard({value}: msgTransferCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRestartCouncil",
-                    value: MsgRestartCouncil.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgTransferCard",
+                    value: MsgTransferCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRestartCouncil: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgTransferCard: Could not create message: ' + e.message)
             }
         },
 
-        msgAddStoryToSet({value}: msgAddStoryToSetParams): EncodeObject {
+        msgBuyBoosterPack({value}: msgBuyBoosterPackParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddStoryToSet",
-                    value: MsgAddStoryToSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgBuyBoosterPack",
+                    value: MsgBuyBoosterPack.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddStoryToSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgBuyBoosterPack: Could not create message: ' + e.message)
             }
         },
 
-        msgReportMatch({value}: msgReportMatchParams): EncodeObject {
+        msgCreateCouncil({value}: msgCreateCouncilParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgReportMatch",
-                    value: MsgReportMatch.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateCouncil",
+                    value: MsgCreateCouncil.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgReportMatch: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCreateCouncil: Could not create message: ' + e.message)
             }
         },
 
-        msgAddCardToSet({value}: msgAddCardToSetParams): EncodeObject {
+        msgDonateToCard({value}: msgDonateToCardParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddCardToSet",
-                    value: MsgAddCardToSet.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgDonateToCard",
+                    value: MsgDonateToCard.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgAddCardToSet: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgDonateToCard: Could not create message: ' + e.message)
             }
         },
 
-        msgRevealCouncilResponse({value}: msgRevealCouncilResponseParams): EncodeObject {
+        msgAddContributorToSet({value}: msgAddContributorToSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRevealCouncilResponse",
-                    value: MsgRevealCouncilResponse.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgAddContributorToSet",
+                    value: MsgAddContributorToSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRevealCouncilResponse: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgAddContributorToSet: Could not create message: ' + e.message)
             }
         },
 
-        msgSetProfileCard({value}: msgSetProfileCardParams): EncodeObject {
+        msgOpenBoosterPack({value}: msgOpenBoosterPackParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetProfileCard",
-                    value: MsgSetProfileCard.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgOpenBoosterPack",
+                    value: MsgOpenBoosterPack.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetProfileCard: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgOpenBoosterPack: Could not create message: ' + e.message)
             }
         },
 
@@ -1555,25 +1634,25 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgSetSetName({value}: msgSetSetNameParams): EncodeObject {
+        msgSetUserBiography({value}: msgSetUserBiographyParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetName",
-                    value: MsgSetSetName.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetUserBiography",
+                    value: MsgSetUserBiography.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgSetSetName: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetUserBiography: Could not create message: ' + e.message)
             }
         },
 
-        msgTransferBoosterPack({value}: msgTransferBoosterPackParams): EncodeObject {
+        msgCreateuser({value}: msgCreateuserParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgTransferBoosterPack",
-                    value: MsgTransferBoosterPack.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCreateuser",
+                    value: MsgCreateuser.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgTransferBoosterPack: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgCreateuser: Could not create message: ' + e.message)
             }
         },
 
@@ -1588,36 +1667,36 @@ export const txClient = ({signer, prefix, addr}: TxClientOptions = {
             }
         },
 
-        msgRemoveSellOffer({value}: msgRemoveSellOfferParams): EncodeObject {
+        msgRemoveContributorFromSet({value}: msgRemoveContributorFromSetParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveSellOffer",
-                    value: MsgRemoveSellOffer.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgRemoveContributorFromSet",
+                    value: MsgRemoveContributorFromSet.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgRemoveSellOffer: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgRemoveContributorFromSet: Could not create message: ' + e.message)
             }
         },
 
-        msgConfirmMatch({value}: msgConfirmMatchParams): EncodeObject {
+        msgSetSetName({value}: msgSetSetNameParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgConfirmMatch",
-                    value: MsgConfirmMatch.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgSetSetName",
+                    value: MsgSetSetName.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgConfirmMatch: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgSetSetName: Could not create message: ' + e.message)
             }
         },
 
-        msgCommitCouncilResponse({value}: msgCommitCouncilResponseParams): EncodeObject {
+        msgInviteEarlyAccess({value}: msgInviteEarlyAccessParams): EncodeObject {
             try {
                 return {
-                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgCommitCouncilResponse",
-                    value: MsgCommitCouncilResponse.fromPartial(value)
+                    typeUrl: "/DecentralCardGame.cardchain.cardchain.MsgInviteEarlyAccess",
+                    value: MsgInviteEarlyAccess.fromPartial(value)
                 }
             } catch (e: any) {
-                throw new Error('TxClient:MsgCommitCouncilResponse: Could not create message: ' + e.message)
+                throw new Error('TxClient:MsgInviteEarlyAccess: Could not create message: ' + e.message)
             }
         },
 
@@ -1661,6 +1740,7 @@ class SDKModule {
             InnerRarities: getStructure(typeInnerRarities.fromPartial({})),
             AddrWithQuantity: getStructure(typeAddrWithQuantity.fromPartial({})),
             SetProposal: getStructure(typeSetProposal.fromPartial({})),
+            EarlyAccess: getStructure(typeEarlyAccess.fromPartial({})),
             BoosterPack: getStructure(typeBoosterPack.fromPartial({})),
             AirDrops: getStructure(typeAirDrops.fromPartial({})),
             VotingResults: getStructure(typeVotingResults.fromPartial({})),