diff --git a/app/test_helpers.go b/app/test_helpers.go index 7401394..e7ee794 100644 --- a/app/test_helpers.go +++ b/app/test_helpers.go @@ -9,7 +9,6 @@ import ( dbm "github.com/tendermint/tm-db" ) -// Setup initializes a new BitsongApp func Setup(isCheckTx bool) *App { db := dbm.NewMemDB() app := New(log.NewNopLogger(), db, nil, true, map[int64]bool{}, DefaultNodeHome, 5, MakeEncodingConfig(), simapp.EmptyAppOptions{}) diff --git a/cosmwasm/README.md b/cosmwasm/README.md index 5914dd3..85d756b 100644 --- a/cosmwasm/README.md +++ b/cosmwasm/README.md @@ -14,7 +14,7 @@ Here's [installation guide](https://doc.rust-lang.org/cargo/getting-started/inst cohod keys add signer --keyring-backend=test --home=$HOME/.cohod --recover # pipe woman clutch absorb lonely cost credit math antique better thumb cook pave clarify hungry east garbage absent warfare song helmet anchor drift purity -cohod tx bank send validator $(cohod keys show -a signer --keyring-backend=test --home=$HOME/.cohod) 1000000stake --keyring-backend=test --home=$HOME/.cohod --broadcast-mode=block -y --chain-id=test +cohod tx bank send validator $(cohod keys show -a signer --keyring-backend=test --home=$HOME/.cohod) 1000000stake --keyring-backend=test --home=$HOME/.cohod --broadcast-mode=block -y --chain-id=qwoyn-1 ``` ## Build Contracts @@ -47,7 +47,7 @@ cohod tx wasm store $WASM_FILE --from $FROM --chain-id $CHAIN_ID --gas auto --ga Example command to upload Ship NFT wasm binary to local test node ``` -cohod tx wasm store ./artifacts/ship_nft.wasm --from validator --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y +cohod tx wasm store ./artifacts/ship_nft.wasm --from validator --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y ``` ## Instantiate Contract @@ -66,7 +66,7 @@ cohod tx wasm instantiate $CODE_ID $INSTANTIATE_MSG --from $FROM --label $LABEL Example command to init Ship NFT contract on local test node ``` -cohod tx wasm instantiate 1 '{"name":"Ship NFT","symbol":"SHIP","minter":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v","owner":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v"}' --from validator --label "Ship-NFT" --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ --no-admin -y +cohod tx wasm instantiate 1 '{"name":"Ship NFT","symbol":"SHIP","minter":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v","owner":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v"}' --from validator --label "Ship-NFT" --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ --no-admin -y ``` ## Get Contract Address @@ -99,7 +99,7 @@ cohod tx wasm execute $CONTRACT_ADDRESS $EXECUTE_MSG --from $FROM --chain-id $CH Example command to mint Ship NFT with token_id "1" ``` -cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"mint":{"token_id":"1","owner":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v","extension":{"ship_type":10,"owner":"100"}}}' --from signer --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y +cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"mint":{"token_id":"1","owner":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v","extension":{"ship_type":10,"owner":"100"}}}' --from signer --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y ``` ## Transfer NFT @@ -107,7 +107,7 @@ cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sn Example command to transfer minted Ship NFT with token_id "1" ``` -cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"transfer_nft":{"token_id":"1","recipient":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v"}}' --from signer --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y +cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"transfer_nft":{"token_id":"1","recipient":"coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v"}}' --from signer --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y ``` ## Get NFT Info @@ -147,7 +147,7 @@ cohod tx wasm execute $CONTRACT_ADDRESS $EXECUTE_MSG --from $FROM --chain-id $CH Example command to update Ship NFT with token_id "1" ``` -cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"update_nft":{"token_id":"1","extension":{"ship_type":20,"owner":"200"}}}' --from signer --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y +cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"update_nft":{"token_id":"1","extension":{"ship_type":20,"owner":"200"}}}' --from signer --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y ``` ## Transfer Ownership @@ -166,5 +166,5 @@ cohod tx wasm execute $CONTRACT_ADDRESS $EXECUTE_MSG --from $FROM --chain-id $CH Example command to transfer ownership to `coho1f0yhatqxayku7y00k448n43qwch320v4da2plx` ``` -cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"transfer_ownership":{"owner":"coho1f0yhatqxayku7y00k448n43qwch320v4da2plx"}}' --from signer --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y +cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"transfer_ownership":{"owner":"coho1f0yhatqxayku7y00k448n43qwch320v4da2plx"}}' --from signer --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y ``` diff --git a/proto/game/genesis.proto b/proto/game/genesis.proto index 35714cb..33ee6db 100644 --- a/proto/game/genesis.proto +++ b/proto/game/genesis.proto @@ -6,6 +6,7 @@ import "google/protobuf/duration.proto"; import "google/protobuf/timestamp.proto"; import "game/params.proto"; import "game/game.proto"; +import "game/liquidity.proto"; option go_package = "github.com/cosmic-horizon/coho/x/game/types"; @@ -16,4 +17,5 @@ message GenesisState { repeated string whitelisted_contracts = 3; repeated Unbonding unbondings = 4 [ (gogoproto.nullable) = false ]; uint64 last_unbonding_id = 5; + Liquidity liquidity = 6 [ (gogoproto.nullable) = false ]; } diff --git a/proto/game/tx.proto b/proto/game/tx.proto index 6ad4b5f..d52baaf 100644 --- a/proto/game/tx.proto +++ b/proto/game/tx.proto @@ -113,3 +113,79 @@ message MsgSwap { cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; } message MsgSwapResponse {} + +message EventTransferModuleOwnership { + string origin_owner = 1; + string new_owner = 2; +} + +message EventNftContractAddWhitelist { + string contract = 1; +} + +message EventNftContractRemoveWhitelist { + string contract = 1; +} + +message EventDepositNft { + string owner = 1; + string contract = 2; + uint64 token_id = 3; +} + +message EventWithdrawNft { + string sender = 1; + string contract = 2; + uint64 token_id = 3; + string exec_msg = 4; +} + +message EventDepositToken { + string sender = 1; + string amount = 2; +} + +message EventWithdrawToken { + string sender = 1; + string amount = 2; +} + +message EventStakeInGameToken { + string sender = 1; + string amount = 2; +} + +message EventClaimInGameStakingReward { + string sender = 1; + string amount = 2; + uint64 reward_claim_time = 3; +} + +message EventBeginUnstakeInGameToken { + string sender = 1; + string amount = 2; + uint64 completion_time = 3; +} + +message EventCompleteUnstakeInGameToken { + string user = 1; + string amount = 2; + uint64 completion_time = 3; + uint64 unbonding_id = 4; +} + +message EventAddLiquidity { + string sender = 1; + string amounts = 2; +} + +message EventRemoveLiquidity { + string sender = 1; + string amounts = 2; +} + +message EventSwap { + string sender = 1; + string in_amount = 2; + string out_amount = 3; +} diff --git a/x/game/client/cli/tx.go b/x/game/client/cli/tx.go index 0e99c86..3a7c9ea 100644 --- a/x/game/client/cli/tx.go +++ b/x/game/client/cli/tx.go @@ -237,7 +237,7 @@ func GetCmdSignWithdrawUpdatedNft() *cobra.Command { func GetCmdWithdrawUpdatedNft() *cobra.Command { cmd := &cobra.Command{ - Use: "withdraw-updated-nft [contract] [tokenId] [execMsg] [flags]", + Use: "withdraw-updated-nft [contract] [tokenId] [execMsg] [signature] [flags]", Long: "Withdraw updated nft", Args: cobra.ExactArgs(4), Example: fmt.Sprintf( @@ -435,7 +435,7 @@ func GetCmdBeginUnstakeInGameToken() *cobra.Command { func GetCmdClaimInGameStakingReward() *cobra.Command { cmd := &cobra.Command{ - Use: "claim-ingame-staking-reward [coin] [flags]", + Use: "claim-ingame-staking-reward [flags]", Long: "Claim ingame staking reward", Args: cobra.ExactArgs(0), Example: fmt.Sprintf( diff --git a/x/game/genesis.go b/x/game/genesis.go index 03f88c4..e809239 100644 --- a/x/game/genesis.go +++ b/x/game/genesis.go @@ -11,6 +11,7 @@ import ( func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) { k.SetParamSet(ctx, genState.Params) k.SetLastUnbondingId(ctx, genState.LastUnbondingId) + k.SetLiquidity(ctx, genState.Liquidity) for _, deposit := range genState.Deposits { k.SetDeposit(ctx, deposit) @@ -33,6 +34,7 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { genesis.WhitelistedContracts = k.GetAllWhitelistedContracts(ctx) genesis.Unbondings = k.GetAllUnbondings(ctx) genesis.LastUnbondingId = k.GetLastUnbondingId(ctx) + genesis.Liquidity = k.GetLiquidity(ctx) return genesis } diff --git a/x/game/keeper/abci.go b/x/game/keeper/abci.go index ff4cda7..e19aab8 100644 --- a/x/game/keeper/abci.go +++ b/x/game/keeper/abci.go @@ -1,6 +1,7 @@ package keeper import ( + "github.com/cosmic-horizon/coho/x/game/types" sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -20,5 +21,13 @@ func (k Keeper) EndBlocker(ctx sdk.Context) { continue } k.DeleteUnbonding(ctx, unbonding) + + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventCompleteUnstakeInGameToken{ + User: unbonding.StakerAddress, + Amount: unbonding.Amount.String(), + CompletionTime: uint64(ctx.BlockTime().Unix()), + UnbondingId: unbonding.Id, + }) } } diff --git a/x/game/keeper/grpc_query.go b/x/game/keeper/grpc_query.go index 42768a8..31fa032 100644 --- a/x/game/keeper/grpc_query.go +++ b/x/game/keeper/grpc_query.go @@ -66,8 +66,15 @@ func (k Keeper) AllDepositBalance(c context.Context, req *types.QueryAllDepositB } ctx := sdk.UnwrapSDKContext(c) + params := k.GetParamSet(ctx) + deposits := k.GetAllDeposits(ctx) + amount := sdk.ZeroInt() + for _, deposit := range deposits { + amount = amount.Add(deposit.Amount) + } return &types.QueryAllDepositBalanceResponse{ - Deposits: k.GetAllDeposits(ctx), + Deposits: deposits, + Amount: sdk.NewCoin(params.DepositDenom, amount), }, nil } diff --git a/x/game/keeper/ingame_unbonding.go b/x/game/keeper/ingame_unbonding.go index 805d67b..93a96d3 100644 --- a/x/game/keeper/ingame_unbonding.go +++ b/x/game/keeper/ingame_unbonding.go @@ -56,7 +56,7 @@ func (k Keeper) GetUserUnbondings(ctx sdk.Context, addr sdk.AccAddress) []types. store := ctx.KVStore(k.storeKey) unbondings := []types.Unbonding{} - it := store.Iterator(types.PrefixInGameUnbondingTimeKey, sdk.InclusiveEndBytes(types.InGameUnbondingUserPrefixKey(addr))) + it := sdk.KVStorePrefixIterator(store, types.InGameUnbondingUserPrefixKey(addr)) defer it.Close() for ; it.Valid(); it.Next() { diff --git a/x/game/keeper/msg_server.go b/x/game/keeper/msg_server.go index d2537b2..cf895f7 100644 --- a/x/game/keeper/msg_server.go +++ b/x/game/keeper/msg_server.go @@ -29,6 +29,13 @@ func (m msgServer) TransferModuleOwnership(goCtx context.Context, msg *types.Msg } params.Owner = msg.NewOwner m.SetParamSet(ctx, params) + + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventTransferModuleOwnership{ + OriginOwner: msg.Sender, + NewOwner: msg.NewOwner, + }) + return &types.MsgTransferModuleOwnershipResponse{}, nil } @@ -69,6 +76,11 @@ func (m msgServer) WhitelistNftContracts(goCtx context.Context, msg *types.MsgWh } m.SetWhitelistedContract(ctx, contract) + + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventNftContractAddWhitelist{ + Contract: contract, + }) } return &types.MsgWhitelistNftContractsResponse{}, nil } @@ -81,6 +93,11 @@ func (m msgServer) RemoveWhitelistedNftContracts(goCtx context.Context, msg *typ } for _, contract := range msg.Contracts { m.DeleteWhitelistedContract(ctx, contract) + + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventNftContractRemoveWhitelist{ + Contract: contract, + }) } return &types.MsgRemoveWhitelistedNftContractsResponse{}, nil } @@ -92,6 +109,13 @@ func (m msgServer) DepositNft(goCtx context.Context, msg *types.MsgDepositNft) ( return nil, err } + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventDepositNft{ + Owner: msg.Sender, + Contract: msg.Contract, + TokenId: msg.TokenId, + }) + return &types.MsgDepositNftResponse{}, nil } @@ -101,6 +125,15 @@ func (m msgServer) WithdrawUpdatedNft(goCtx context.Context, msg *types.MsgWithd if err != nil { return nil, err } + + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventWithdrawNft{ + Sender: msg.Sender, + Contract: msg.Contract, + TokenId: msg.TokenId, + ExecMsg: msg.ExecMsg, + }) + return &types.MsgWithdrawUpdatedNftResponse{}, nil } @@ -123,6 +156,12 @@ func (m msgServer) DepositToken(goCtx context.Context, msg *types.MsgDepositToke m.IncreaseDeposit(ctx, sender, msg.Amount.Amount) + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventDepositToken{ + Sender: msg.Sender, + Amount: msg.Amount.String(), + }) + return &types.MsgDepositTokenResponse{}, nil } @@ -145,6 +184,12 @@ func (m msgServer) WithdrawToken(goCtx context.Context, msg *types.MsgWithdrawTo m.DecreaseDeposit(ctx, sender, msg.Amount.Amount) + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventWithdrawToken{ + Sender: msg.Sender, + Amount: msg.Amount.String(), + }) + return &types.MsgWithdrawTokenResponse{}, nil } @@ -170,6 +215,11 @@ func (m msgServer) StakeInGameToken(goCtx context.Context, msg *types.MsgStakeIn return nil, err } + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventStakeInGameToken{ + Sender: msg.Sender, + Amount: msg.Amount.String(), + }) return &types.MsgStakeInGameTokenResponse{}, nil } @@ -207,6 +257,13 @@ func (m msgServer) BeginUnstakeInGameToken(goCtx context.Context, msg *types.Msg Amount: msg.Amount.Amount, }) + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventBeginUnstakeInGameToken{ + Sender: msg.Sender, + Amount: msg.Amount.String(), + CompletionTime: uint64(ctx.BlockTime().Add(params.UnstakingTime).Unix()), + }) + return &types.MsgBeginUnstakeInGameTokenResponse{}, nil } @@ -250,6 +307,12 @@ func (m msgServer) AddLiquidity(goCtx context.Context, msg *types.MsgAddLiquidit return nil, err } + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventAddLiquidity{ + Sender: msg.Sender, + Amounts: sdk.Coins(msg.Amounts).String(), + }) + return &types.MsgAddLiquidityResponse{}, nil } @@ -276,6 +339,12 @@ func (m msgServer) RemoveLiquidity(goCtx context.Context, msg *types.MsgRemoveLi return nil, err } + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventRemoveLiquidity{ + Sender: msg.Sender, + Amounts: sdk.Coins(msg.Amounts).String(), + }) + return &types.MsgRemoveLiquidityResponse{}, nil } @@ -311,5 +380,12 @@ func (m msgServer) Swap(goCtx context.Context, msg *types.MsgSwap) (*types.MsgSw return nil, err } + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventSwap{ + Sender: msg.Sender, + InAmount: msg.Amount.String(), + OutAmount: tarCoin.String(), + }) + return &types.MsgSwapResponse{}, nil } diff --git a/x/game/keeper/token.go b/x/game/keeper/token.go index 0276e4a..995a93c 100644 --- a/x/game/keeper/token.go +++ b/x/game/keeper/token.go @@ -139,5 +139,12 @@ func (k Keeper) ClaimInGameStakingReward(ctx sdk.Context, addr sdk.AccAddress) e deposit.RewardClaimTime = ctx.BlockTime() k.SetDeposit(ctx, deposit) + // emit event + ctx.EventManager().EmitTypedEvent(&types.EventClaimInGameStakingReward{ + Sender: addr.String(), + Amount: rewardAmount.String(), + RewardClaimTime: uint64(ctx.BlockTime().Unix()), + }) + return nil } diff --git a/x/game/spec/01_state.md b/x/game/spec/01_state.md new file mode 100644 index 0000000..ba414a3 --- /dev/null +++ b/x/game/spec/01_state.md @@ -0,0 +1,93 @@ + + +# State + +## Game tokens + +### Deposit + +`Deposit` is used for tracking deposited game tokens by each user. This object tracks deposit amount, staking amount, total unbonding amount by the user. + +```protobuf +message Deposit { + string address = 1; + string amount = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; + string staking = 3 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; + string unbonding = 4 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; + google.protobuf.Timestamp reward_claim_time = 5 [ (gogoproto.nullable) = false, (gogoproto.stdtime) = true ]; +} +``` + +- Deposit: `0x02 | format(address) -> Deposit` + +### Unbonding + +`Unbonding` is used for tracking unbonding entries that has unbonding period based on module parameter. + +```protobuf +message Unbonding { + uint64 id = 1; + string staker_address = 2; + int64 creation_height = 3; + google.protobuf.Timestamp completion_time = 4 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + string amount = 5 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} +``` + +- Unbonding: `0x03 | format(unbonding_id) -> Unbonding` +- Unbonding by user: `0x04 | format(address) | format(unbonding_id) -> format(unbonding_id)` +- Unbonding by time: `0x05 | format(unbonding_completion_time) | format(unbonding_id) -> format(unbonding_id)` +- Last unbonding index: `0x06 | format(unbonding_id) -> format(last_unbonding_id)` + +## Liquidity + +`Liquidity` is available on game module to provide token swap between game token and native token. +Liquidity can only be added or removed by module owner. + +```protobuf +message Liquidity { + repeated cosmos.base.v1beta1.Coin amounts = 1 [ (gogoproto.nullable) = false ]; +} +``` + +- Liquidity: `0x07 -> Liquidity` + +## Game nfts + +### Whitelisted contracts + +Game item nft contracts are all registered by module owner before any deposit/withdraw operation. +Whitelisted contract's owner should be set to `game` module account to be registered. + +- Whitelisted contract: `0x01 | contract_addr -> contract_addr` + +## Params + +Params is a module-wide configuration structure that stores system parameters that is governed by `gov` module. +Params contains `owner`(module owner), `deposit_denom` (game token), `staking_inflation` (in game staking %), `unstaking_time` (unstaking period for in game staking). + +```protobuf +message Params { + string owner = 1; + string deposit_denom = 2; + uint64 staking_inflation = 3; // percentage + google.protobuf.Duration unstaking_time = 4 [(gogoproto.nullable) = false, (gogoproto.stdduration) = true]; +} +``` + +- Params: `Paramsspace("game") -> Params` diff --git a/x/game/spec/02_messages.md b/x/game/spec/02_messages.md new file mode 100644 index 0000000..e89c5e4 --- /dev/null +++ b/x/game/spec/02_messages.md @@ -0,0 +1,267 @@ + + +# Messages + +In this section we describe the processing of the game module messages and the corresponding updates to the state. + +## MsgTransferModuleOwnership + +`MsgTransferModuleOwnership` is a message to transfer module ownership by current module owner. + +```protobuf +message MsgTransferModuleOwnership { + string sender = 1; + string newOwner = 2; +} +``` + +Steps: + +1. Ensure `msg.Sender` is module owner +2. Update module owner to `msg.NewOwner` +3. Emit `EventTransferModuleOwnership` event + +## MsgWhitelistNftContracts + +`MsgWhitelistNftContracts` is a message to whitelist multiple nft contracts by module owner. + +```protobuf +message MsgWhitelistNftContracts { + string sender = 1; + repeated string contracts = 2; +} +``` + +Steps: + +1. Ensure `msg.Sender` is module owner +2. Iterate `msg.Contracts` and execute followings +3. Ensure contract minter is set to module owner +4. Ensure contract owner is set to module owner +5. Add contract to whitelisted +6. Emit `EventNftContractAddWhitelist` event + +## MsgRemoveWhitelistedNftContracts + +`MsgRemoveWhitelistedNftContracts` is a message to remove multiple nft contracts from whitelist by module owner. + +```protobuf +message MsgRemoveWhitelistedNftContracts { + string sender = 1; + repeated string contracts = 2; +} +``` + +Steps: + +1. Ensure `msg.Sender` is module owner +2. Iterate `msg.Contracts` and execute followings +3. Remove contract from whitelisted +4. Emit `EventNftContractRemoveWhitelist` event + +## MsgDepositNft + +`MsgDepositNft` is a message to deposit a whitelist nft by the nft owner. + +```protobuf +message MsgDepositNft { + string sender = 1; + string contract = 2; + uint64 token_id = 3; +} +``` + +Steps: + +1. Ensure that nft contract (`msg.Contract`) is whitelisted +2. Execute wasm contract `"transfer_nft"` to send nft from `msg.Sender` to module address +3. Ensure wasm contract execution does not fail +4. Emit `EventDepositNft` event + +## MsgWithdrawUpdatedNft + +`MsgWithdrawUpdatedNft` is a message to withdraw modified nft from the module from module owner's signature. + +```protobuf +message MsgWithdrawUpdatedNft { + string sender = 1; + string contract = 2; + uint64 token_id = 3; + string exec_msg = 4; + bytes signature = 5; +} +``` + +Steps: + +1. Get sign bytes to check signature of module owner +2. Verify `msg.Signature` with module owner pubKey and sign bytes +3. Execute nft updates and ensure that no error happens +4. Execute wasm contract `"transfer_nft"` to send nft from module address to `msg.Sender`. +5. Ensure wasm contract execution does not fail +6. Emit `EventWithdrawNft` event + +### MsgSignerWithdrawUpdatedNft + +`MsgSignerWithdrawUpdatedNft` is a message used for sign bytes for `MsgWithdrawUpdatedNft`. + +```protobuf +message MsgSignerWithdrawUpdatedNft { + string sender = 1; + string contract = 2; + uint64 token_id = 3; + string exec_msg = 4; +} +``` + +## MsgDepositToken + +`MsgDepositToken` is a message to deposit in game token into the game. + +```protobuf +message MsgDepositToken { + string sender = 1; + cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; +} +``` + +Steps: + +1. Ensure `msg.Amount.Denom` is deposit denom (game token) +2. Deposit coins from `msg.Sender` to module account +3. Increase deposit amount of `msg.Sender` by `msg.Amount.Amount` +4. Emit `EventDepositToken` event + +## MsgWithdrawToken + +`MsgWithdrawToken` is a message to withdraw in game token from the game. + +```protobuf +message MsgWithdrawToken { + string sender = 1; + cosmos.base.v1beta1.Coin amount = 2 [(gogoproto.nullable) = false]; +} +``` + +Steps: + +1. Ensure `msg.Amount.Denom` is deposit denom (game token) +2. Withdrw coins from module account to `msg.Sender` +3. Decrease deposit amount of `msg.Sender` by `msg.Amount.Amount` +4. Emit `EventWithdrawToken` event + +## MsgStakeInGameToken + +`MsgStakeInGameToken` is a message to stake in-game token to get more game tokens. + +```protobuf +message MsgStakeInGameToken { + string sender = 1; + cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; +} +``` + +Steps: + +1. Ensure `msg.Amount.Denom` is deposit denom (game token) +2. Claim in game staking reward collected so far +3. Ensure that `staking + amount` does not exceed `deposit.Amount` +4. Increase staking amount +5. Emit `EventStakeInGameToken` event + +## MsgBeginUnstakeInGameToken + +`MsgBeginUnstakeInGameToken` is a message to begin unstaking game token. This starts unbonding process and it's automatically unbonded after `params.unstaking_time` pass. + +```protobuf +message MsgBeginUnstakeInGameToken { + string sender = 1; + cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; +} +``` + +Steps: + +1. Ensure `msg.Amount.Denom` is deposit denom (game token) +2. Claim in game staking reward collected so far +3. Ensure that `unbonding + amount` does not exceed `deposit.Unbonding` +4. Increase unbonding amount +5. Generate new unbonding id +6. Put unbonding object on unbonding queue with new unbonding id +7. Emit `EventBeginUnstakeInGameToken` event + +## MsgClaimInGameStakingReward + +`MsgClaimInGameStakingReward` is a message to claim in game staking reward by staker. + +```protobuf +message MsgClaimInGameStakingReward { + string sender = 1; +} +``` + +Steps: + +1. Calculate reward amount from staking amount and `StakingInflation` parameter +2. If reward amount is positive, mint coins to module and increase `deposit.Amount` +3. Set reward claim time +4. Emit `EventClaimInGameStakingReward` event + +## MsgAddLiquidity + +`MsgAddLiquidity` is a message to add liquidity by module owner for game token and governance token. + +```protobuf +message MsgAddLiquidity { + string sender = 1; + repeated cosmos.base.v1beta1.Coin amounts = 2 [ (gogoproto.nullable) = false ]; +} +``` + +Steps: + +1. Ensure that transaction is executed by module owner +2. Increase liquidity amount by `msg.Amounts` +3. Ensure that only two tokens are added as liquidity +4. Deposit coins from module owner account to the module +5. Emit `EventAddLiquidity` event + +## MsgRemoveLiquidity + +`MsgRemoveLiquidity` is a message to add liquidity by module owner for game token and governance token. + +```protobuf +message MsgRemoveLiquidity { + string sender = 1; + repeated cosmos.base.v1beta1.Coin amounts = 2 [ (gogoproto.nullable) = false ]; +} +``` + +Steps: + +1. Ensure that transaction is executed by module owner +2. Decrease liquidity amount by `msg.Amounts` +3. Withdraw coins from module owner account to the module +4. Emit `EventRemoveLiquidity` event + +## MsgSwap + +`MsgSwap` is a message to swap on liquidity between game token and governance token. + +```protobuf +message MsgSwap { + string sender = 1; + cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; +} +``` + +Steps: + +1. Transfer input amount to the module account +2. Calculate swap out amount from current liquidity and input amount +3. Transfer calculated amount from module account to `msg.Sender` +4. Increase liquidity by deposit amount +5. Decrease liquidity by withdraw amount +6. Emit `EventSwap` event diff --git a/x/game/spec/03_end_block.md b/x/game/spec/03_end_block.md new file mode 100644 index 0000000..1f8cb8b --- /dev/null +++ b/x/game/spec/03_end_block.md @@ -0,0 +1,21 @@ + + +# End-Block + +Each abci end block call, unbonding queue is updated. + +## Unbonding queue + +In game staking has unbonding period and when a user begins unbonding of in game staking token, +`Unbonding` object is put on the queue and when the time pass, endblock automatically checks the +list of matured unbondings and deducts the staking amount of the user. + +### Steps + +1. Iterate matured unbondings and for each unbonding +2. Decrease `deposit.Staking` amount +3. Decrease `deposit.Unbonding` amount +4. Delete unbonding object +5. Emit `EventCompleteUnstakeInGameToken` event diff --git a/x/game/spec/04_events.md b/x/game/spec/04_events.md new file mode 100644 index 0000000..b0ce0a4 --- /dev/null +++ b/x/game/spec/04_events.md @@ -0,0 +1,189 @@ + + +# Events + +The game module emits the following events: + +## EndBlocker + +| Type | Attribute Key | Attribute Value | +| ------------------------------------------------------- | --------------- | --------------- | +| cosmichorizon.coho.game.EventCompleteUnstakeInGameToken | user | {user} | +| cosmichorizon.coho.game.EventCompleteUnstakeInGameToken | amount | {amount} | +| cosmichorizon.coho.game.EventCompleteUnstakeInGameToken | completion_time | {timestamp} | +| cosmichorizon.coho.game.EventCompleteUnstakeInGameToken | unbonding_id | {unbonding_id} | + +## Msg's + +### MsgTransferModuleOwnership + +| Type | Attribute Key | Attribute Value | +| ---------------------------------------------------- | ------------- | --------------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgTransferModuleOwnership | +| cosmichorizon.coho.game.EventTransferModuleOwnership | origin_owner | {origin_owner} | +| cosmichorizon.coho.game.EventTransferModuleOwnership | new_owner | {new_owner} | + +### MsgWhitelistNftContracts + +| Type | Attribute Key | Attribute Value | +| ---------------------------------------------------- | ------------- | ------------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgWhitelistNftContracts | +| cosmichorizon.coho.game.EventNftContractAddWhitelist | contract | {contract_addr} | + +### MsgRemoveWhitelistedNftContracts + +| Type | Attribute Key | Attribute Value | +| ------------------------------------------------------- | ------------- | --------------------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgRemoveWhitelistedNftContracts | +| cosmichorizon.coho.game.EventNftContractRemoveWhitelist | contract | {contract_addr} | + +### MsgDepositNft + +| Type | Attribute Key | Attribute Value | +| --------------------------------------- | ------------------ | -------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgDepositNft | +| cosmichorizon.coho.game.EventDepositNft | contract | {contract_addr} | +| cosmichorizon.coho.game.EventDepositNft | token_id | {token_id} | +| cosmichorizon.coho.game.EventDepositNft | owner | {owner} | +| execute | \_contract_address | {contract_addr} | +| wasm | token_id | {token_id} | +| wasm | recipient | {recipient} | +| wasm | sender | {sender} | +| wasm | action | transfer_nft | +| wasm | \_contract_address | contract_addr | + +### MsgWithdrawUpdatedNft + +| Type | Attribute Key | Attribute Value | +| ---------------------------------------- | ------------------ | ---------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgWithdrawUpdatedNft | +| cosmichorizon.coho.game.EventWithdrawNft | sender | {sender} | +| cosmichorizon.coho.game.EventWithdrawNft | contract | {contract} | +| cosmichorizon.coho.game.EventWithdrawNft | token_id | {token_id} | +| cosmichorizon.coho.game.EventWithdrawNft | exec_msg | {exec_msg} | +| execute | \_contract_address | {contract_addr} | +| wasm | token_id | {token_id} | +| wasm | recipient | {recipient} | +| wasm | sender | {sender} | +| wasm | action | transfer_nft | +| wasm | \_contract_address | {contract_addr} | +| wasm | token_id | {token_id} | +| wasm | owner | {owner} | +| wasm | minter | {minter} | +| wasm | action | mint | +| wasm | \_contract_address | {contract_addr} | + +### MsgDepositToken + +| Type | Attribute Key | Attribute Value | +| ----------------------------------------- | ------------- | ---------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgDepositToken | +| message | sender | {sender} | +| cosmichorizon.coho.game.EventDepositToken | sender | {sender} | +| cosmichorizon.coho.game.EventDepositToken | amount | {amount} | +| coin_spent | spender | {spender} | +| coin_spent | amount | {amount} | +| coin_received | receiver | {receiver} | +| coin_received | amount | {amount} | +| transfer | recipient | {recipient} | +| transfer | sender | {sender} | +| transfer | amount | {amount} | + +### MsgWithdrawToken + +| Type | Attribute Key | Attribute Value | +| ------------------------------------------ | ------------- | ---------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgDepositToken | +| message | sender | {sender} | +| cosmichorizon.coho.game.EventWithdrawToken | sender | {sender} | +| cosmichorizon.coho.game.EventWithdrawToken | amount | {amount} | +| coin_spent | spender | {spender} | +| coin_spent | amount | {amount} | +| coin_received | receiver | {receiver} | +| coin_received | amount | {amount} | +| transfer | recipient | {recipient} | +| transfer | sender | {sender} | +| transfer | amount | {amount} | + +### MsgStakeInGameToken + +| Type | Attribute Key | Attribute Value | +| ----------------------------------------------------- | ----------------- | -------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgStakeInGameToken | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | sender | {sender} | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | amount | {amount} | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | reward_claim_time | {reward_claim_time} | +| cosmichorizon.coho.game.EventStakeInGameToken | sender | {sender} | +| cosmichorizon.coho.game.EventStakeInGameToken | amount | {amount} | + +### MsgBeginUnstakeInGameToken + +| Type | Attribute Key | Attribute Value | +| ----------------------------------------------------- | ----------------- | --------------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgBeginUnstakeInGameToken | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | sender | {sender} | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | amount | {amount} | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | reward_claim_time | {reward_claim_time} | +| cosmichorizon.coho.game.EventBeginUnstakeInGameToken | sender | {sender} | +| cosmichorizon.coho.game.EventBeginUnstakeInGameToken | amount | {amount} | +| cosmichorizon.coho.game.EventBeginUnstakeInGameToken | completion_time | {completion_time} | + +### MsgClaimInGameStakingReward + +| Type | Attribute Key | Attribute Value | +| ----------------------------------------------------- | ----------------- | ---------------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgClaimInGameStakingReward | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | sender | {sender} | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | amount | {amount} | +| cosmichorizon.coho.game.EventClaimInGameStakingReward | reward_claim_time | {reward_claim_time} | + +### MsgAddLiquidity + +| Type | Attribute Key | Attribute Value | +| ----------------------------------------- | ------------- | ---------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgAddLiquidity | +| message | sender | {sender} | +| cosmichorizon.coho.game.EventAddLiquidity | sender | {sender} | +| cosmichorizon.coho.game.EventAddLiquidity | amount | {amount} | +| coin_spent | spender | {spender} | +| coin_spent | amount | {amount} | +| coin_received | receiver | {receiver} | +| coin_received | amount | {amount} | +| transfer | recipient | {recipient} | +| transfer | sender | {sender} | +| transfer | amount | {amount} | + +### MsgRemoveLiquidity + +| Type | Attribute Key | Attribute Value | +| -------------------------------------------- | ------------- | ------------------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgRemoveLiquidity | +| message | sender | {sender} | +| cosmichorizon.coho.game.EventRemoveLiquidity | sender | {sender} | +| cosmichorizon.coho.game.EventRemoveLiquidity | amount | {amount} | +| coin_spent | spender | {spender} | +| coin_spent | amount | {amount} | +| coin_received | receiver | {receiver} | +| coin_received | amount | {amount} | +| transfer | recipient | {recipient} | +| transfer | sender | {sender} | +| transfer | amount | {amount} | + +### MsgSwap + +| Type | Attribute Key | Attribute Value | +| --------------------------------- | ------------- | -------------------------------- | +| message | action | /cosmichorizon.coho.game.MsgSwap | +| message | sender | {sender} | +| cosmichorizon.coho.game.EventSwap | sender | {sender} | +| cosmichorizon.coho.game.EventSwap | in_amount | {in_amount} | +| cosmichorizon.coho.game.EventSwap | out_amount | {out_amount} | +| []coin_spent | spender | {spender} | +| []coin_spent | amount | {amount} | +| []coin_received | receiver | {receiver} | +| []coin_received | amount | {amount} | +| []transfer | recipient | {recipient} | +| []transfer | sender | {sender} | +| []transfer | amount | {amount} | diff --git a/x/game/spec/05_params.md b/x/game/spec/05_params.md new file mode 100644 index 0000000..1853c58 --- /dev/null +++ b/x/game/spec/05_params.md @@ -0,0 +1,14 @@ + + +# Parameters + +The game module contains the following parameters: + +| Key | Type | Example | +| ---------------- | ---------------- | --------------------------------------------- | +| Owner | address | "coho1gp39e7eahjehykfuywzvn2gswfqz22wpukygpa" | +| DepositDenom | string | "ucoho" | +| StakingInflation | uint64 | 1 | +| UnstakingTime | string (time ns) | "259200000000000" | diff --git a/x/game/spec/06_client.md b/x/game/spec/06_client.md new file mode 100644 index 0000000..b54b251 --- /dev/null +++ b/x/game/spec/06_client.md @@ -0,0 +1,460 @@ + + +# Client + +## CLI + +A user can query and interact with the `game` module using the CLI. + +### Query + +The `query` commands allows users to query `game` module state. + +```bash +cohod query game --help +``` + +#### params + +The `params` command allows users to query values set as game module parameters. + +```bash +# usage +cohod query game params [flags] + +# example +cohod query game params +``` + +Example Output: + +```bash +params: + deposit_denom: stake + owner: coho1x0fha27pejg5ajg8vnrqm33ck8tq6raafkwa9v + staking_inflation: "1" + unstaking_time: 30s +``` + +#### whitelisted contracts + +The `whitelisted-contracts` command allows users to query whitelisted nft contracts. + +Usage: + +```bash +# usage +cohod query game whitelisted-contracts [flags] + +# example +cohod query game whitelisted-contracts +``` + +Example Output: + +```bash +contracts: +- coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc +``` + +#### all deposit balances + +The `all-deposit-balances` command allow users to query all deposits. + +```bash +# usage +cohod query game all-deposit-balances [flags] + +# example +cohod query game all-deposit-balances +``` + +Example Output: + +```bash +amount: + amount: "1000000" + denom: stake +deposits: +- address: coho1tpug77hddm558x39gzndx72w94zgfstzk95rdy + amount: "1000000" + reward_claim_time: "0001-01-01T00:00:00Z" + staking: "0" + unbonding: "0" +``` + +#### deposit balance + +The `deposit-balance` command allow users to query a single deposit. + +```bash +# usage +cohod query game deposit-balance [address] [flags] + +# example +cohod query game deposit-balance coho1tpug77hddm558x39gzndx72w94zgfstzk95rdy +``` + +Example Output: + +```bash +deposit: + address: coho1tpug77hddm558x39gzndx72w94zgfstzk95rdy + amount: "1000000" + reward_claim_time: "0001-01-01T00:00:00Z" + staking: "0" + unbonding: "0" +``` + +#### all unbondings + +The `all-unbondings` command allow users to query all active unbondings. + +```bash +# usage +cohod query game all-unbondings [flags] +# example +cohod query game all-unbondings +``` + +Example Output: + +```bash +unbondings: +- amount: "100000" + completion_time: "2022-09-13T13:07:14.682492Z" + creation_height: "178" + id: "1" + staker_address: coho1tpug77hddm558x39gzndx72w94zgfstzk95rdy +``` + +#### user unbondings + +The `user-unbondings` command allow users to query all active unbondings for an address. + +```bash +# usage +cohod query game user-unbondings [address] [flags] +# example +cohod query game user-unbondings $(cohod keys show -a validator --keyring-backend=test) +``` + +Example Output: + +```bash +unbondings: +- amount: "100000" + completion_time: "2022-09-13T13:16:18.650478Z" + creation_height: "283" + id: "2" + staker_address: coho1tpug77hddm558x39gzndx72w94zgfstzk95rdy +``` + +#### liquidity + +The `liquidity` command allow users to query total liquidity put for coho and qwoyn. + +```bash +# usage +cohod query game liquidity [flags] +# example +cohod query game liquidity +``` + +Example Output: + +```bash +liquidity: + amounts: + - amount: "1000000" + denom: ucoho + - amount: "1000000" + denom: uqwoyn +``` + +#### estimate swap out + +The `estimated-swap-out` command allow users to query estimated out amount on swap operation. + +```bash +# bash +cohod query game estimated-swap-out [amount] [flags] +# example +cohod query game estimated-swap-out 10000ucoho +``` + +Example Output: + +```bash +amount: + amount: "9901" + denom: uqwoyn +``` + +#### swap rate + +The `swap-rate` command allow users to query spot price on current liquidity. + +```bash +# usage +cohod query game swap-rate [flags] +# example +cohod query game swap-rate +``` + +Example Output: + +```bash +rate: "1.000000000000000000" +src_denom: ucoho +tar_denom: uqwoyn +``` + +### Transactions + +The `tx` commands allows users to interact with the `game` module. + +```bash +cohod tx game --help +``` + +#### MsgTransferModuleOwnership + +The command `transfer-module-ownership` allows the module owner to transfer the ownership to a different address. + +Usage: + +```bash +cohod tx game transfer-module-ownership [newOwner] [flags] +``` + +Example: + +```bash +cohod tx game transfer-module-ownership coho1tpug77hddm558x39gzndx72w94zgfstzk95rdy \ + --from=moduleOwner +``` + +## MsgWhitelistNftContracts + +The command `whitelist-contracts` allows the module owner to whitelist nft contracts deployed on cosmwasm. + +Usage: + +```bash +cohod tx game whitelist-contracts [contracts] [flags] +``` + +Example: + +```bash +cohod tx game whitelist-contracts coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc \ + --from=moduleOwner +``` + +## MsgRemoveWhitelistedNftContracts + +The command `remove-whitelisted-contracts` allows the module owner to remove whitelisted nft contracts. + +Usage: + +```bash +cohod tx game remove-whitelisted-contracts [contracts] [flags] +``` + +Example: + +```bash +cohod tx game remove-whitelisted-contracts coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc \ + --from=moduleOwner +``` + +## MsgDepositNft + +The command `deposit-nft` allows a user to deposit a whitelisted nft. + +Usage: + +```bash +cohod tx game deposit-nft [contract] [tokenId] [flags] +``` + +Example: + +```bash +cohod tx game deposit-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 1 \ + --from=user +``` + +## MsgSignerWithdrawUpdatedNft + +The command `sign-withdraw-updated-nft` allows the module owner to generate signature for a user to withdraw an nft with updates. + +Usage: + +```bash +cohod tx game sign-withdraw-updated-nft [contract] [tokenId] [execMsg] [flags] +``` + +Example: + +```bash +cohod tx game sign-withdraw-updated-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 1 '{"update_nft":{"token_id":"1","extension":{"ship_type":67,"owner":"200"}}}' \ + --from=moduleOwner +``` + +## MsgWithdrawUpdatedNft + +The command `withdraw-updated-nft` allows a user to withdraw a deposited nft with updates by using module owner signature. + +Usage: + +```bash +cohod tx game withdraw-updated-nft [contract] [tokenId] [execMsg] [signature] [flags] +``` + +Example: + +```bash +cohod tx game withdraw-updated-nft '{"update_nft":{"token_id":"1","extension":{"ship_type":67,"owner":"200"}}}' \ + 42d6e9d3b62ffc9b0bc3f6a97cbc0857af1c7a7aa57549571d7bc72415a955d978a1790440ce53c8f9fbfa2ce70d967812eda6094d6f112d7e5736170e48e2a8 \ + --from=user +``` + +## MsgDepositToken + +The command `deposit-token` allows a user to deposit game tokens by users. + +Usage: + +```bash +cohod tx game deposit-token deposit-token [coin] [flags] +``` + +Example: + +```bash +cohod tx game deposit-token 1000000stake \ + --from=user +``` + +## MsgWithdrawToken + +The command `withdraw-token` allows a user to withdraw game tokens by users. + +Usage: + +```bash +cohod tx game withdraw-token [coin] [flags] +``` + +Example: + +```bash +cohod tx game withdraw-token 1000000stake \ + --from=user +``` + +## MsgStakeInGameToken + +The command `stake-ingame-token` allows a user to stake deposited game tokens by users. + +Usage: + +```bash +cohod tx game stake-ingame-token [coin] [flags] +``` + +Example: + +```bash +cohod tx game stake-ingame-token 1000000stake \ + --from=user +``` + +## MsgBeginUnstakeInGameToken + +The command `begin-unstake-ingame-token` allows a user to begin unstake of staked game tokens by users. + +Usage: + +```bash +cohod tx game begin-unstake-ingame-token [coin] [flags] +``` + +Example: + +```bash +cohod tx game begin-unstake-ingame-token 1000000stake \ + --from=user +``` + +## MsgClaimInGameStakingReward + +The command `claim-ingame-staking-reward` allows a user to claim rewards from staked game tokens. + +Usage: + +```bash +cohod tx game claim-ingame-staking-reward [flags] +``` + +Example: + +```bash +cohod tx game claim-ingame-staking-reward \ + --from=user +``` + +## MsgAddLiquidity + +The command `add-liquidity` allows the module owner to put liquidity for game tokens and governance tokens. + +Usage: + +```bash +cohod tx game add-liquidity [coins] [flags] +``` + +Example: + +```bash +cohod tx game add-liquidity 10000ucoho,10000uqwoyn \ + --from=user +``` + +## MsgRemoveLiquidity + +The command `remove-liquidity` allows the module owner to remove liquidity. + +Usage: + +```bash +cohod tx game remove-liquidity [coins] [flags] +``` + +Example: + +```bash +cohod tx game remove-liquidity 10000ucoho,10000uqwoyn \ + --from=user +``` + +## MsgSwap + +The command `swap` allows a user to to swap on liquidity. + +Usage: + +```bash +cohod tx game swap [coin] [flags] +``` + +Example: + +```bash +cohod tx game swap 10000ucoho \ + --from=user +``` diff --git a/x/game/spec/Test.md b/x/game/spec/07_cli_examples.md similarity index 65% rename from x/game/spec/Test.md rename to x/game/spec/07_cli_examples.md index aefca14..f1d6f4d 100644 --- a/x/game/spec/Test.md +++ b/x/game/spec/07_cli_examples.md @@ -30,6 +30,9 @@ cohod tx game claim-ingame-staking-reward --from=validator --chain-id=qwoyn-1 -- # whitelist contract cohod tx game whitelist-contracts coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block +# remove whitelisted contract +cohod tx game remove-whitelisted-contracts coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block + # deposit nft from end wallet to game cohod tx game deposit-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 1 --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block @@ -39,23 +42,39 @@ cohod query wasm contract-state smart coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcm # game module address # coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk +# add signer +cohod keys add signer --keyring-backend=test --home=$HOME/.cohod --recover +# pipe woman clutch absorb lonely cost credit math antique better thumb cook pave clarify hungry east garbage absent warfare song helmet anchor drift purity + +cohod tx bank send validator $(cohod keys show -a signer --keyring-backend=test --home=$HOME/.cohod) 1000000stake --keyring-backend=test --home=$HOME/.cohod --broadcast-mode=block -y --chain-id=qwoyn-1 + +# upload wasm +cohod tx wasm store ./artifacts/ship_nft.wasm --from validator --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y + # instantiate ship nft with module account owned -cohod tx wasm instantiate 1 '{"name":"Ship NFT","symbol":"SHIP","minter":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk","owner":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk"}' --from validator --label "Ship-NFT" --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ --no-admin -y +cohod tx wasm instantiate 1 '{"name":"Ship NFT","symbol":"SHIP","minter":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk","owner":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk"}' --from validator --label "Ship-NFT" --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ --no-admin -y # transfer nft update ownership to module account - when owner is set to different account -cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"transfer_ownership":{"owner":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk"}}' --from signer --chain-id test --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y +cohod tx wasm execute coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc '{"transfer_ownership":{"owner":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk"}}' --from signer --chain-id qwoyn-1 --gas auto --gas-adjustment 1.3 -b block --keyring-backend=test --home=$HOME/.cohod/ -y cohod tx game sign-withdraw-updated-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 1 '{"update_nft":{"token_id":"1","extension":{"ship_type":67,"owner":"200"}}}' --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ cohod tx game withdraw-updated-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 1 '{"update_nft":{"token_id":"1","extension":{"ship_type":67,"owner":"200"}}}' 42d6e9d3b62ffc9b0bc3f6a97cbc0857af1c7a7aa57549571d7bc72415a955d978a1790440ce53c8f9fbfa2ce70d967812eda6094d6f112d7e5736170e48e2a8 --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block --gas=400000 -cohod tx game withdraw-updated-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 2 '{"mint":{"token_id":"2","owner":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk","extension":{"ship_type":12,"owner":"300"}}}' --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block +cohod tx game withdraw-updated-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 2 '{"mint":{"token_id":"2","owner":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk","extension":{"ship_type":12,"owner":"300"}}}' 6a859feb353f0c49b9316cf871738f6d21a14320edb4817cdbfbcab7c6434cb10ab1b8debd61109c3726872d19b8090c7e3ae3c2cf87fe69de3533fe92127251 --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block --gas=300000 + +cohod tx game sign-withdraw-updated-nft coho14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9snm4thc 2 '{"mint":{"token_id":"2","owner":"coho1djju4dm7wqk8s76vzjea80exht2rmfsxjx47wk","extension":{"ship_type":12,"owner":"300"}}}' --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block # send tokens to admin to add liquidity cohod tx bank send validator $(cohod keys show -a signer --keyring-backend=test) 1000000ucoho,1000000uqwoyn --from=validator --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block # add liquidity cohod tx game add-liquidity 1000000ucoho,1000000uqwoyn --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block +# remove liquidity +cohod tx game remove-liquidity 10000ucoho,10000uqwoyn --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block cohod tx game swap 10000ucoho --from=validator --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block + +# transfer module ownership +cohod tx game transfer-module-ownership $(cohod keys show -a signer --keyring-backend=test) --from=signer --chain-id=qwoyn-1 --keyring-backend=test --home=$HOME/.cohod/ -y --broadcast-mode=block ``` diff --git a/x/game/spec/08_talk.md b/x/game/spec/08_talk.md new file mode 100644 index 0000000..95d3913 --- /dev/null +++ b/x/game/spec/08_talk.md @@ -0,0 +1,32 @@ +# In-game items / funds manager module + +## module accounts + +- `active_use` module account + - Permanantly linked to Avatar + - Enabled and Disabled at specific locations ie. Cryo chamber, Shipyard, Bank + - Avatar can use any items and funds on this module account. + - Everything is managed off-chain for tokens and nfts put in `active_use` vault. + - Planets only exist in `active_use` account +- `sales_use` module account + - items for sale will be stored in this account + - user cannot cancel sale + - creates nft(deed) tied to items for sale + - deed can then be transferred to end wallet +- `starports` accounts: these accounts will get coho rewards, and it's switched to sagans +- `retirement_account` interchain account which retires credits on behalf of the player + +## functions + +- deposit item +- deposit funds +- withdraw item (items are changed during the game execution) +- claim new item earned during the game +- withdraw funds + +All of the withdraw functionalities should have signature from game manager account. +There could be multiple game manager for security. + +## thoughts + +- In game funds can be staked for staking rewards? Yes. Sagans will be put in banks and the interest from storing your sagans in the banks will provide the staking rewards/inflation. diff --git a/x/game/spec/README.md b/x/game/spec/README.md index 95d3913..33bbf4e 100644 --- a/x/game/spec/README.md +++ b/x/game/spec/README.md @@ -1,32 +1,42 @@ -# In-game items / funds manager module + -## module accounts +# `game` -- `active_use` module account - - Permanantly linked to Avatar - - Enabled and Disabled at specific locations ie. Cryo chamber, Shipyard, Bank - - Avatar can use any items and funds on this module account. - - Everything is managed off-chain for tokens and nfts put in `active_use` vault. - - Planets only exist in `active_use` account -- `sales_use` module account - - items for sale will be stored in this account - - user cannot cancel sale - - creates nft(deed) tied to items for sale - - deed can then be transferred to end wallet -- `starports` accounts: these accounts will get coho rewards, and it's switched to sagans -- `retirement_account` interchain account which retires credits on behalf of the player +## Abstract -## functions +This module provides interface for game tokens and nfts deposit, withdrawal and token liquidity/swap operations. +Goal of the module is to manage in game items and tokens securely on-chain. -- deposit item -- deposit funds -- withdraw item (items are changed during the game execution) -- claim new item earned during the game -- withdraw funds +## Contents -All of the withdraw functionalities should have signature from game manager account. -There could be multiple game manager for security. - -## thoughts - -- In game funds can be staked for staking rewards? Yes. Sagans will be put in banks and the interest from storing your sagans in the banks will provide the staking rewards/inflation. +1. **[State](01_state.md)** + - [Game tokens](01_state.md#game-tokens) + - [Liquidity](01_state.md#liquidity) + - [Game nfts](01_state.md#params) + - [Params](01_state.md#params) +2. **[Messages](02_messages.md)** + - [MsgTransferModuleOwnership](02_messages.md#msgtransfermoduleownership) + - [MsgWhitelistNftContracts](02_messages.md#msgwhitelistnftcontracts) + - [MsgRemoveWhitelistedNftContracts](02_messages.md#msgremovewhitelistednftcontracts) + - [MsgDepositNft](02_messages.md#msgdepositnft) + - [MsgWithdrawUpdatedNft](02_messages.md#msgwithdrawupdatednft) + - [MsgDepositToken](02_messages.md#msgdeposittoken) + - [MsgWithdrawToken](02_messages.md#msgwithdrawtoken) + - [MsgStakeInGameToken](02_messages.md#msgstakeingametoken) + - [MsgBeginUnstakeInGameToken](02_messages.md#msgbeginunstakeingametoken) + - [MsgClaimInGameStakingReward](02_messages.md#msgclaimingamestakingreward) + - [MsgAddLiquidity](02_messages.md#msgaddliquidity) + - [MsgRemoveLiquidity](02_messages.md#msgremoveliquidity) + - [MsgSwap](02_messages.md#msgswap) +3. **[End-Block](03_end_block.md)** + - [Unbonding queue](03_end_block.md#unbonding-queue) +4. **[Events](04_events.md)** + - [EndBlocker](07_events.md#endblocker) + - [Msg's](07_events.md#msg's) +5. **[Parameters](05_params.md)** +6. **[Client](06_client.md)** diff --git a/x/game/types/genesis.pb.go b/x/game/types/genesis.pb.go index 3cf1fdd..cae0e70 100644 --- a/x/game/types/genesis.pb.go +++ b/x/game/types/genesis.pb.go @@ -32,6 +32,7 @@ type GenesisState struct { WhitelistedContracts []string `protobuf:"bytes,3,rep,name=whitelisted_contracts,json=whitelistedContracts,proto3" json:"whitelisted_contracts,omitempty"` Unbondings []Unbonding `protobuf:"bytes,4,rep,name=unbondings,proto3" json:"unbondings"` LastUnbondingId uint64 `protobuf:"varint,5,opt,name=last_unbonding_id,json=lastUnbondingId,proto3" json:"last_unbonding_id,omitempty"` + Liquidity Liquidity `protobuf:"bytes,6,opt,name=liquidity,proto3" json:"liquidity"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -102,6 +103,13 @@ func (m *GenesisState) GetLastUnbondingId() uint64 { return 0 } +func (m *GenesisState) GetLiquidity() Liquidity { + if m != nil { + return m.Liquidity + } + return Liquidity{} +} + func init() { proto.RegisterType((*GenesisState)(nil), "cosmichorizon.coho.game.GenesisState") } @@ -109,30 +117,32 @@ func init() { func init() { proto.RegisterFile("game/genesis.proto", fileDescriptor_06c25d2b62eeb762) } var fileDescriptor_06c25d2b62eeb762 = []byte{ - // 357 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xcf, 0x4a, 0xeb, 0x40, - 0x14, 0xc6, 0x93, 0xb6, 0xb7, 0xdc, 0x3b, 0xbd, 0x50, 0x1a, 0x2a, 0x86, 0x2e, 0xd2, 0xd0, 0x55, - 0x50, 0xcc, 0x40, 0xbb, 0x76, 0x53, 0x15, 0x75, 0x27, 0x15, 0x37, 0x6e, 0xca, 0x24, 0x19, 0x27, - 0x03, 0x4d, 0x4e, 0xc8, 0x9c, 0xe0, 0x9f, 0xa7, 0xf0, 0x81, 0x7c, 0x80, 0x2e, 0xbb, 0x74, 0x25, - 0xd2, 0xbe, 0x88, 0x24, 0x99, 0x96, 0x22, 0x74, 0x97, 0xcc, 0xf7, 0xfb, 0xce, 0xf9, 0xc1, 0x21, - 0x96, 0x60, 0x09, 0xa7, 0x82, 0xa7, 0x5c, 0x49, 0xe5, 0x67, 0x39, 0x20, 0x58, 0xc7, 0x21, 0xa8, - 0x44, 0x86, 0x31, 0xe4, 0xf2, 0x0d, 0x52, 0x3f, 0x84, 0x18, 0xfc, 0x12, 0x1b, 0xf4, 0x05, 0x08, - 0xa8, 0x18, 0x5a, 0x7e, 0xd5, 0xf8, 0xc0, 0x11, 0x00, 0x62, 0xc1, 0x69, 0xf5, 0x17, 0x14, 0x4f, - 0x34, 0x2a, 0x72, 0x86, 0x12, 0x52, 0x9d, 0x0f, 0x7f, 0xe7, 0x28, 0x13, 0xae, 0x90, 0x25, 0x99, - 0x06, 0x7a, 0x95, 0x43, 0xc6, 0x72, 0x96, 0x68, 0x85, 0x41, 0xb7, 0xd6, 0x62, 0x09, 0xaf, 0x1f, - 0x46, 0x1f, 0x0d, 0xf2, 0xff, 0xba, 0xb6, 0xbc, 0x47, 0x86, 0xdc, 0x3a, 0x27, 0xed, 0xba, 0x61, - 0x9b, 0xae, 0xe9, 0x75, 0xc6, 0x43, 0xff, 0x80, 0xb5, 0x7f, 0x57, 0x61, 0xd3, 0xd6, 0xf2, 0x6b, - 0x68, 0xcc, 0x74, 0xc9, 0x9a, 0x92, 0xbf, 0x11, 0xcf, 0x40, 0x49, 0x54, 0x76, 0xc3, 0x6d, 0x7a, - 0x9d, 0xb1, 0x7b, 0x70, 0xc0, 0x65, 0x0d, 0xea, 0x09, 0xbb, 0x9e, 0x35, 0x21, 0x47, 0xcf, 0xb1, - 0x44, 0xbe, 0x90, 0x0a, 0x79, 0x34, 0x0f, 0x21, 0xc5, 0x9c, 0x85, 0xa8, 0xec, 0xa6, 0xdb, 0xf4, - 0xfe, 0xcd, 0xfa, 0x7b, 0xe1, 0xc5, 0x36, 0xb3, 0x6e, 0x08, 0x29, 0xd2, 0x00, 0xd2, 0x48, 0xa6, - 0x42, 0xd9, 0xad, 0x6a, 0xf5, 0xe8, 0xe0, 0xea, 0x87, 0x2d, 0xaa, 0x97, 0xef, 0x75, 0xad, 0x13, - 0xd2, 0x5b, 0x30, 0x85, 0xf3, 0xdd, 0xd3, 0x5c, 0x46, 0xf6, 0x1f, 0xd7, 0xf4, 0x5a, 0xb3, 0x6e, - 0x19, 0xec, 0xba, 0xb7, 0xd1, 0xf4, 0x6a, 0xb9, 0x76, 0xcc, 0xd5, 0xda, 0x31, 0xbf, 0xd7, 0x8e, - 0xf9, 0xbe, 0x71, 0x8c, 0xd5, 0xc6, 0x31, 0x3e, 0x37, 0x8e, 0xf1, 0x78, 0x2a, 0x24, 0xc6, 0x45, - 0xe0, 0x87, 0x90, 0xd0, 0xda, 0xe2, 0x4c, 0x6b, 0xd0, 0x52, 0x83, 0xbe, 0x54, 0x57, 0xa0, 0xf8, - 0x9a, 0x71, 0x15, 0xb4, 0xab, 0x63, 0x4c, 0x7e, 0x02, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x63, 0xb8, - 0x3d, 0x36, 0x02, 0x00, 0x00, + // 387 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xbf, 0xaa, 0xdb, 0x30, + 0x18, 0xc5, 0xed, 0x3a, 0x0d, 0x8d, 0x52, 0x08, 0x11, 0x29, 0x35, 0x19, 0x1c, 0x93, 0xc9, 0xb4, + 0xd4, 0x82, 0x64, 0xee, 0x92, 0xfe, 0x87, 0x0e, 0x25, 0xa5, 0x4b, 0x97, 0x20, 0xdb, 0xaa, 0x2c, + 0xb0, 0xfd, 0xb9, 0x96, 0x4c, 0x9b, 0xce, 0x7d, 0x80, 0x3e, 0x56, 0xc6, 0x8c, 0x9d, 0x2e, 0x97, + 0xe4, 0x45, 0x2e, 0x96, 0x15, 0xdf, 0x70, 0xc1, 0x9b, 0xfd, 0x9d, 0xdf, 0x39, 0xe7, 0x93, 0x84, + 0x30, 0xa7, 0x39, 0x23, 0x9c, 0x15, 0x4c, 0x0a, 0x19, 0x96, 0x15, 0x28, 0xc0, 0xcf, 0x63, 0x90, + 0xb9, 0x88, 0x53, 0xa8, 0xc4, 0x1f, 0x28, 0xc2, 0x18, 0x52, 0x08, 0x1b, 0x6c, 0x3e, 0xe3, 0xc0, + 0x41, 0x33, 0xa4, 0xf9, 0x6a, 0xf1, 0xb9, 0xc7, 0x01, 0x78, 0xc6, 0x88, 0xfe, 0x8b, 0xea, 0x1f, + 0x24, 0xa9, 0x2b, 0xaa, 0x04, 0x14, 0x46, 0x5f, 0x3c, 0xd4, 0x95, 0xc8, 0x99, 0x54, 0x34, 0x2f, + 0x0d, 0x30, 0xd5, 0x3b, 0x94, 0xb4, 0xa2, 0xb9, 0x59, 0x61, 0x3e, 0x69, 0xd7, 0xa2, 0x39, 0x33, + 0x83, 0x99, 0x1e, 0x64, 0xe2, 0x67, 0x2d, 0x12, 0xa1, 0xf6, 0xed, 0x74, 0xf9, 0xd7, 0x41, 0x4f, + 0x3f, 0xb4, 0xbb, 0x7f, 0x55, 0x54, 0x31, 0xfc, 0x1a, 0x0d, 0xdb, 0x1c, 0xd7, 0xf6, 0xed, 0x60, + 0xbc, 0x5a, 0x84, 0x3d, 0x67, 0x09, 0xbf, 0x68, 0x6c, 0x33, 0x38, 0xdc, 0x2c, 0xac, 0xad, 0x31, + 0xe1, 0x0d, 0x7a, 0x92, 0xb0, 0x12, 0xa4, 0x50, 0xd2, 0x7d, 0xe4, 0x3b, 0xc1, 0x78, 0xe5, 0xf7, + 0x06, 0xbc, 0x6d, 0x41, 0x93, 0xd0, 0xf9, 0xf0, 0x1a, 0x3d, 0xfb, 0x95, 0x0a, 0xc5, 0x32, 0x21, + 0x15, 0x4b, 0x76, 0x31, 0x14, 0xaa, 0xa2, 0xb1, 0x92, 0xae, 0xe3, 0x3b, 0xc1, 0x68, 0x3b, 0xbb, + 0x12, 0xdf, 0x5c, 0x34, 0xfc, 0x11, 0xa1, 0xba, 0x88, 0xa0, 0x48, 0x44, 0xc1, 0xa5, 0x3b, 0xd0, + 0xd5, 0xcb, 0xde, 0xea, 0x6f, 0x17, 0xd4, 0x94, 0x5f, 0x79, 0xf1, 0x0b, 0x34, 0xcd, 0xa8, 0x54, + 0xbb, 0x6e, 0xb4, 0x13, 0x89, 0xfb, 0xd8, 0xb7, 0x83, 0xc1, 0x76, 0xd2, 0x08, 0x9d, 0xf7, 0x53, + 0x82, 0xdf, 0xa3, 0x51, 0x77, 0xa3, 0xee, 0x50, 0x5f, 0x58, 0x7f, 0xe9, 0xe7, 0x0b, 0x69, 0x4a, + 0xef, 0xad, 0x9b, 0x77, 0x87, 0x93, 0x67, 0x1f, 0x4f, 0x9e, 0x7d, 0x7b, 0xf2, 0xec, 0x7f, 0x67, + 0xcf, 0x3a, 0x9e, 0x3d, 0xeb, 0xff, 0xd9, 0xb3, 0xbe, 0xbf, 0xe4, 0x42, 0xa5, 0x75, 0x14, 0xc6, + 0x90, 0x93, 0x36, 0xf8, 0x95, 0x49, 0x26, 0x4d, 0x32, 0xf9, 0xad, 0xdf, 0x98, 0xa8, 0x7d, 0xc9, + 0x64, 0x34, 0xd4, 0x8f, 0xba, 0xbe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x19, 0x53, 0xeb, 0xab, 0x94, + 0x02, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -155,6 +165,16 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size, err := m.Liquidity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 if m.LastUnbondingId != 0 { i = encodeVarintGenesis(dAtA, i, uint64(m.LastUnbondingId)) i-- @@ -250,6 +270,8 @@ func (m *GenesisState) Size() (n int) { if m.LastUnbondingId != 0 { n += 1 + sovGenesis(uint64(m.LastUnbondingId)) } + l = m.Liquidity.Size() + n += 1 + l + sovGenesis(uint64(l)) return n } @@ -440,6 +462,39 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { break } } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Liquidity", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Liquidity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/game/types/tx.pb.go b/x/game/types/tx.pb.go index b8ae63f..25509c3 100644 --- a/x/game/types/tx.pb.go +++ b/x/game/types/tx.pb.go @@ -1303,1451 +1303,1419 @@ func (m *MsgSwapResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgSwapResponse proto.InternalMessageInfo -func init() { - proto.RegisterType((*MsgTransferModuleOwnership)(nil), "cosmichorizon.coho.game.MsgTransferModuleOwnership") - proto.RegisterType((*MsgTransferModuleOwnershipResponse)(nil), "cosmichorizon.coho.game.MsgTransferModuleOwnershipResponse") - proto.RegisterType((*MsgWhitelistNftContracts)(nil), "cosmichorizon.coho.game.MsgWhitelistNftContracts") - proto.RegisterType((*MsgWhitelistNftContractsResponse)(nil), "cosmichorizon.coho.game.MsgWhitelistNftContractsResponse") - proto.RegisterType((*MsgRemoveWhitelistedNftContracts)(nil), "cosmichorizon.coho.game.MsgRemoveWhitelistedNftContracts") - proto.RegisterType((*MsgRemoveWhitelistedNftContractsResponse)(nil), "cosmichorizon.coho.game.MsgRemoveWhitelistedNftContractsResponse") - proto.RegisterType((*MsgDepositNft)(nil), "cosmichorizon.coho.game.MsgDepositNft") - proto.RegisterType((*MsgDepositNftResponse)(nil), "cosmichorizon.coho.game.MsgDepositNftResponse") - proto.RegisterType((*TokenInfoExtension)(nil), "cosmichorizon.coho.game.TokenInfoExtension") - proto.RegisterType((*MsgSignerWithdrawUpdatedNft)(nil), "cosmichorizon.coho.game.MsgSignerWithdrawUpdatedNft") - proto.RegisterType((*MsgWithdrawUpdatedNft)(nil), "cosmichorizon.coho.game.MsgWithdrawUpdatedNft") - proto.RegisterType((*MsgWithdrawUpdatedNftResponse)(nil), "cosmichorizon.coho.game.MsgWithdrawUpdatedNftResponse") - proto.RegisterType((*MsgDepositToken)(nil), "cosmichorizon.coho.game.MsgDepositToken") - proto.RegisterType((*MsgDepositTokenResponse)(nil), "cosmichorizon.coho.game.MsgDepositTokenResponse") - proto.RegisterType((*MsgWithdrawToken)(nil), "cosmichorizon.coho.game.MsgWithdrawToken") - proto.RegisterType((*MsgWithdrawTokenResponse)(nil), "cosmichorizon.coho.game.MsgWithdrawTokenResponse") - proto.RegisterType((*MsgStakeInGameToken)(nil), "cosmichorizon.coho.game.MsgStakeInGameToken") - proto.RegisterType((*MsgStakeInGameTokenResponse)(nil), "cosmichorizon.coho.game.MsgStakeInGameTokenResponse") - proto.RegisterType((*MsgBeginUnstakeInGameToken)(nil), "cosmichorizon.coho.game.MsgBeginUnstakeInGameToken") - proto.RegisterType((*MsgBeginUnstakeInGameTokenResponse)(nil), "cosmichorizon.coho.game.MsgBeginUnstakeInGameTokenResponse") - proto.RegisterType((*MsgClaimInGameStakingReward)(nil), "cosmichorizon.coho.game.MsgClaimInGameStakingReward") - proto.RegisterType((*MsgClaimInGameStakingRewardResponse)(nil), "cosmichorizon.coho.game.MsgClaimInGameStakingRewardResponse") - proto.RegisterType((*MsgAddLiquidity)(nil), "cosmichorizon.coho.game.MsgAddLiquidity") - proto.RegisterType((*MsgAddLiquidityResponse)(nil), "cosmichorizon.coho.game.MsgAddLiquidityResponse") - proto.RegisterType((*MsgRemoveLiquidity)(nil), "cosmichorizon.coho.game.MsgRemoveLiquidity") - proto.RegisterType((*MsgRemoveLiquidityResponse)(nil), "cosmichorizon.coho.game.MsgRemoveLiquidityResponse") - proto.RegisterType((*MsgSwap)(nil), "cosmichorizon.coho.game.MsgSwap") - proto.RegisterType((*MsgSwapResponse)(nil), "cosmichorizon.coho.game.MsgSwapResponse") +type EventTransferModuleOwnership struct { + OriginOwner string `protobuf:"bytes,1,opt,name=origin_owner,json=originOwner,proto3" json:"origin_owner,omitempty"` + NewOwner string `protobuf:"bytes,2,opt,name=new_owner,json=newOwner,proto3" json:"new_owner,omitempty"` } -func init() { proto.RegisterFile("game/tx.proto", fileDescriptor_497c523f337df817) } - -var fileDescriptor_497c523f337df817 = []byte{ - // 887 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0x4d, 0x6f, 0xeb, 0x44, - 0x14, 0x8d, 0x5f, 0x43, 0xf3, 0x7a, 0x69, 0xf5, 0x1e, 0xe6, 0x95, 0xb8, 0xa6, 0x4d, 0x23, 0xf3, - 0xa1, 0x40, 0xc1, 0x26, 0x2d, 0x1f, 0xaa, 0x60, 0xd3, 0x96, 0x0a, 0x55, 0x22, 0x50, 0x99, 0x56, - 0x45, 0x5d, 0x50, 0x39, 0xf6, 0xc4, 0x19, 0x5a, 0xcf, 0x18, 0x8f, 0xd3, 0xa4, 0x88, 0x2d, 0x62, - 0x81, 0x84, 0xf8, 0x03, 0x88, 0x7f, 0x83, 0xba, 0xec, 0x92, 0x15, 0x42, 0xed, 0x1f, 0x41, 0x1e, - 0xc7, 0x93, 0x8f, 0xc6, 0x4e, 0x52, 0x35, 0x62, 0x97, 0xf1, 0x9c, 0x7b, 0xce, 0xf1, 0xf8, 0xde, - 0x39, 0x0a, 0x2c, 0xb9, 0x96, 0x87, 0x8c, 0xb0, 0xa3, 0xfb, 0x01, 0x0d, 0xa9, 0x5c, 0xb4, 0x29, - 0xf3, 0xb0, 0xdd, 0xa4, 0x01, 0xfe, 0x91, 0x12, 0xdd, 0xa6, 0x4d, 0xaa, 0x47, 0x08, 0xb5, 0x14, - 0x6d, 0x50, 0x66, 0xd4, 0x2d, 0x86, 0x8c, 0xcb, 0x6a, 0x1d, 0x85, 0x56, 0xd5, 0xb0, 0x29, 0x26, - 0x71, 0xa1, 0xfa, 0xc2, 0xa5, 0x2e, 0xe5, 0x3f, 0x8d, 0xe8, 0x57, 0xfc, 0x54, 0x3b, 0x04, 0xb5, - 0xc6, 0xdc, 0xa3, 0xc0, 0x22, 0xac, 0x81, 0x82, 0x1a, 0x75, 0x5a, 0x17, 0xe8, 0xeb, 0x36, 0x41, - 0x01, 0x6b, 0x62, 0x5f, 0x7e, 0x0d, 0xe6, 0x19, 0x22, 0x0e, 0x0a, 0x14, 0xa9, 0x2c, 0x55, 0x16, - 0xcc, 0xee, 0x4a, 0x56, 0xe1, 0x29, 0x41, 0x6d, 0x8e, 0x53, 0x9e, 0xf0, 0x1d, 0xb1, 0xd6, 0xde, - 0x04, 0x2d, 0x9d, 0xd1, 0x44, 0xcc, 0xa7, 0x84, 0x21, 0xed, 0x10, 0x94, 0x1a, 0x73, 0x4f, 0x9a, - 0x38, 0x44, 0x17, 0x98, 0x85, 0x5f, 0x35, 0xc2, 0x3d, 0x4a, 0xc2, 0xc0, 0xb2, 0x43, 0x96, 0xaa, - 0xba, 0x0a, 0x0b, 0x76, 0x02, 0x52, 0x9e, 0x94, 0xe7, 0x2a, 0x0b, 0x66, 0xef, 0x81, 0xa6, 0x41, - 0x39, 0x8d, 0x51, 0xa8, 0x7e, 0xcb, 0x31, 0x26, 0xf2, 0xe8, 0x25, 0x12, 0x48, 0xe4, 0x3c, 0x82, - 0xfa, 0xbb, 0x50, 0x19, 0xc7, 0x2c, 0x5c, 0x7c, 0x07, 0x4b, 0x35, 0xe6, 0x7e, 0x8e, 0x7c, 0xca, - 0x70, 0xe4, 0x33, 0xeb, 0x98, 0x13, 0x85, 0xe4, 0x98, 0x93, 0xb5, 0xbc, 0x02, 0x4f, 0x43, 0x7a, - 0x8e, 0xc8, 0x19, 0x76, 0x94, 0xb9, 0xb2, 0x54, 0xc9, 0x9b, 0x05, 0xbe, 0x3e, 0x70, 0xb4, 0x22, - 0x2c, 0x0f, 0xf0, 0x0b, 0xe1, 0x17, 0x20, 0x1f, 0x71, 0x0c, 0x69, 0xd0, 0xfd, 0x4e, 0x88, 0x08, - 0xc3, 0x94, 0x68, 0xbf, 0x48, 0xf0, 0x7a, 0x8d, 0xb9, 0xdf, 0x60, 0x97, 0xa0, 0xe0, 0x04, 0x87, - 0x4d, 0x27, 0xb0, 0xda, 0xc7, 0xbe, 0x63, 0xc5, 0xfe, 0x1f, 0xd9, 0x5d, 0xb4, 0x85, 0x3a, 0xc8, - 0x3e, 0xf3, 0x98, 0xab, 0xe4, 0x79, 0x59, 0x21, 0x5a, 0xd7, 0x98, 0xab, 0xfd, 0x29, 0x71, 0xe7, - 0xff, 0xa7, 0x87, 0xe8, 0x33, 0x33, 0xec, 0x12, 0x2b, 0x6c, 0x05, 0x48, 0x79, 0xa9, 0x2c, 0x55, - 0x16, 0xcd, 0xde, 0x03, 0x6d, 0x1d, 0xd6, 0x46, 0x1a, 0x14, 0x47, 0x5c, 0x87, 0x67, 0xbd, 0xb3, - 0xe7, 0x87, 0x9d, 0xea, 0xfd, 0x13, 0x98, 0xb7, 0x3c, 0xda, 0x22, 0xb1, 0xf3, 0x97, 0x37, 0x57, - 0xf4, 0x78, 0x82, 0xf5, 0x68, 0x82, 0xf5, 0xee, 0x04, 0xeb, 0x7b, 0x14, 0x93, 0xdd, 0xfc, 0xf5, - 0x3f, 0xeb, 0x39, 0xb3, 0x0b, 0xd7, 0x56, 0xa0, 0x38, 0xa4, 0x21, 0xe4, 0x6d, 0x78, 0xde, 0xe7, - 0x6f, 0x46, 0xfa, 0x6a, 0x3c, 0xbb, 0xfd, 0x22, 0xc2, 0x40, 0x03, 0x5e, 0x8d, 0x7a, 0x29, 0xb4, - 0xce, 0xd1, 0x01, 0xf9, 0xc2, 0xf2, 0xd0, 0x8c, 0x3c, 0xac, 0xc5, 0x3d, 0x3b, 0xa4, 0x23, 0x6c, - 0x78, 0xfc, 0x5a, 0xdb, 0x45, 0x2e, 0x26, 0xc7, 0x84, 0xcd, 0xdc, 0x4d, 0x7c, 0xe7, 0xa5, 0xc8, - 0x09, 0x53, 0x1f, 0x71, 0xcf, 0x7b, 0x17, 0x16, 0xf6, 0xe2, 0xed, 0xc8, 0x3e, 0x26, 0xae, 0x89, - 0xda, 0x56, 0xe0, 0xa4, 0xb9, 0xd2, 0xde, 0x82, 0x37, 0x32, 0xca, 0x04, 0xbb, 0xc3, 0x3b, 0x6f, - 0xc7, 0x71, 0xbe, 0xc4, 0x3f, 0xb4, 0xb0, 0x83, 0xc3, 0xab, 0xd4, 0xf7, 0xdc, 0x86, 0x42, 0x6c, - 0x3c, 0xbe, 0xc8, 0x26, 0x78, 0xd1, 0x04, 0xdf, 0xed, 0xbd, 0x7e, 0x15, 0x61, 0xc0, 0x05, 0x59, - 0x5c, 0x81, 0x33, 0xf5, 0xb0, 0xca, 0x3f, 0xee, 0x90, 0x90, 0xb0, 0x71, 0x0a, 0x85, 0xa8, 0x33, - 0xda, 0x96, 0xff, 0xf8, 0xdf, 0xf9, 0x15, 0x7e, 0xc6, 0x11, 0x77, 0x22, 0xb7, 0xf9, 0xd7, 0x22, - 0xcc, 0x45, 0xf7, 0xc6, 0xaf, 0x12, 0x14, 0xd3, 0x62, 0x74, 0x4b, 0x4f, 0x09, 0x6d, 0x3d, 0x3d, - 0x29, 0xd5, 0x4f, 0x1f, 0x50, 0x94, 0xb8, 0x92, 0x7f, 0x96, 0x60, 0x79, 0x74, 0xb8, 0x56, 0xb3, - 0x68, 0x47, 0x96, 0xa8, 0xdb, 0x53, 0x97, 0x08, 0x1f, 0x7f, 0x48, 0xb0, 0x96, 0x1d, 0xb7, 0x99, - 0xe4, 0x99, 0xa5, 0xea, 0xce, 0x83, 0x4b, 0x85, 0x3f, 0x07, 0xa0, 0x2f, 0x87, 0xdf, 0xce, 0x22, - 0xec, 0xe1, 0x54, 0x7d, 0x32, 0x9c, 0x50, 0xf9, 0x09, 0xe4, 0x11, 0x99, 0x96, 0xc9, 0x72, 0x1f, - 0xaf, 0x7e, 0x3c, 0x1d, 0x5e, 0xa8, 0x7f, 0x0f, 0x8b, 0x03, 0x79, 0x54, 0x99, 0xc0, 0x3d, 0x47, - 0xaa, 0x1f, 0x4c, 0x8a, 0x14, 0x5a, 0x1e, 0x2c, 0x0d, 0x86, 0xcf, 0x3b, 0x93, 0x98, 0x8e, 0xd5, - 0xaa, 0x13, 0x43, 0x85, 0xdc, 0x25, 0x3c, 0xbf, 0x17, 0x35, 0xef, 0x65, 0xd1, 0x0c, 0xa3, 0xd5, - 0x0f, 0xa7, 0x41, 0x0b, 0xdd, 0x68, 0xd8, 0xd3, 0xc2, 0x25, 0x73, 0xd8, 0x53, 0x8a, 0xb2, 0x87, - 0x7d, 0x4c, 0xae, 0xc8, 0xbf, 0x49, 0xa0, 0xa4, 0xa6, 0x4a, 0xe6, 0x0b, 0xa6, 0x55, 0xa9, 0x9f, - 0x3d, 0xa4, 0xaa, 0xbf, 0xe3, 0x06, 0x72, 0x28, 0xb3, 0xe3, 0xfa, 0x91, 0xd9, 0x1d, 0x37, 0x2a, - 0x75, 0x64, 0x06, 0xcf, 0x86, 0x23, 0x67, 0x63, 0xfc, 0xbd, 0xd0, 0x53, 0xdc, 0x9a, 0x02, 0x2c, - 0x44, 0x4d, 0xc8, 0xf3, 0x80, 0x29, 0x67, 0x76, 0x4f, 0xdb, 0xf2, 0xd5, 0xca, 0x38, 0x44, 0xc2, - 0xb9, 0xbb, 0x7f, 0x7d, 0x5b, 0x92, 0x6e, 0x6e, 0x4b, 0xd2, 0xbf, 0xb7, 0x25, 0xe9, 0xf7, 0xbb, - 0x52, 0xee, 0xe6, 0xae, 0x94, 0xfb, 0xfb, 0xae, 0x94, 0x3b, 0xdd, 0x70, 0x71, 0xd8, 0x6c, 0xd5, - 0x75, 0x9b, 0x7a, 0x46, 0xcc, 0xf6, 0x7e, 0x97, 0xce, 0x88, 0xe8, 0x8c, 0x8e, 0x11, 0xff, 0x45, - 0xbc, 0xf2, 0x11, 0xab, 0xcf, 0xf3, 0xff, 0x75, 0x5b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xf1, - 0x46, 0xf3, 0xa3, 0x37, 0x0e, 0x00, 0x00, +func (m *EventTransferModuleOwnership) Reset() { *m = EventTransferModuleOwnership{} } +func (m *EventTransferModuleOwnership) String() string { return proto.CompactTextString(m) } +func (*EventTransferModuleOwnership) ProtoMessage() {} +func (*EventTransferModuleOwnership) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{28} +} +func (m *EventTransferModuleOwnership) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventTransferModuleOwnership) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventTransferModuleOwnership.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EventTransferModuleOwnership) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventTransferModuleOwnership.Merge(m, src) +} +func (m *EventTransferModuleOwnership) XXX_Size() int { + return m.Size() +} +func (m *EventTransferModuleOwnership) XXX_DiscardUnknown() { + xxx_messageInfo_EventTransferModuleOwnership.DiscardUnknown(m) } -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 +var xxx_messageInfo_EventTransferModuleOwnership proto.InternalMessageInfo -// MsgClient is the client API for Msg service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type MsgClient interface { - TransferModuleOwnership(ctx context.Context, in *MsgTransferModuleOwnership, opts ...grpc.CallOption) (*MsgTransferModuleOwnershipResponse, error) - WhitelistNftContracts(ctx context.Context, in *MsgWhitelistNftContracts, opts ...grpc.CallOption) (*MsgWhitelistNftContractsResponse, error) - RemoveWhitelistedNftContracts(ctx context.Context, in *MsgRemoveWhitelistedNftContracts, opts ...grpc.CallOption) (*MsgRemoveWhitelistedNftContractsResponse, error) - DepositNft(ctx context.Context, in *MsgDepositNft, opts ...grpc.CallOption) (*MsgDepositNftResponse, error) - WithdrawUpdatedNft(ctx context.Context, in *MsgWithdrawUpdatedNft, opts ...grpc.CallOption) (*MsgWithdrawUpdatedNftResponse, error) - DepositToken(ctx context.Context, in *MsgDepositToken, opts ...grpc.CallOption) (*MsgDepositTokenResponse, error) - WithdrawToken(ctx context.Context, in *MsgWithdrawToken, opts ...grpc.CallOption) (*MsgWithdrawTokenResponse, error) - StakeInGameToken(ctx context.Context, in *MsgStakeInGameToken, opts ...grpc.CallOption) (*MsgStakeInGameTokenResponse, error) - BeginUnstakeInGameToken(ctx context.Context, in *MsgBeginUnstakeInGameToken, opts ...grpc.CallOption) (*MsgBeginUnstakeInGameTokenResponse, error) - ClaimInGameStakingReward(ctx context.Context, in *MsgClaimInGameStakingReward, opts ...grpc.CallOption) (*MsgClaimInGameStakingRewardResponse, error) - AddLiquidity(ctx context.Context, in *MsgAddLiquidity, opts ...grpc.CallOption) (*MsgAddLiquidityResponse, error) - RemoveLiquidity(ctx context.Context, in *MsgRemoveLiquidity, opts ...grpc.CallOption) (*MsgRemoveLiquidityResponse, error) - Swap(ctx context.Context, in *MsgSwap, opts ...grpc.CallOption) (*MsgSwapResponse, error) +func (m *EventTransferModuleOwnership) GetOriginOwner() string { + if m != nil { + return m.OriginOwner + } + return "" } -type msgClient struct { - cc grpc1.ClientConn +func (m *EventTransferModuleOwnership) GetNewOwner() string { + if m != nil { + return m.NewOwner + } + return "" } -func NewMsgClient(cc grpc1.ClientConn) MsgClient { - return &msgClient{cc} +type EventNftContractAddWhitelist struct { + Contract string `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"` } -func (c *msgClient) TransferModuleOwnership(ctx context.Context, in *MsgTransferModuleOwnership, opts ...grpc.CallOption) (*MsgTransferModuleOwnershipResponse, error) { - out := new(MsgTransferModuleOwnershipResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/TransferModuleOwnership", in, out, opts...) - if err != nil { - return nil, err +func (m *EventNftContractAddWhitelist) Reset() { *m = EventNftContractAddWhitelist{} } +func (m *EventNftContractAddWhitelist) String() string { return proto.CompactTextString(m) } +func (*EventNftContractAddWhitelist) ProtoMessage() {} +func (*EventNftContractAddWhitelist) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{29} +} +func (m *EventNftContractAddWhitelist) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventNftContractAddWhitelist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventNftContractAddWhitelist.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *EventNftContractAddWhitelist) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventNftContractAddWhitelist.Merge(m, src) +} +func (m *EventNftContractAddWhitelist) XXX_Size() int { + return m.Size() +} +func (m *EventNftContractAddWhitelist) XXX_DiscardUnknown() { + xxx_messageInfo_EventNftContractAddWhitelist.DiscardUnknown(m) } -func (c *msgClient) WhitelistNftContracts(ctx context.Context, in *MsgWhitelistNftContracts, opts ...grpc.CallOption) (*MsgWhitelistNftContractsResponse, error) { - out := new(MsgWhitelistNftContractsResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/WhitelistNftContracts", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_EventNftContractAddWhitelist proto.InternalMessageInfo + +func (m *EventNftContractAddWhitelist) GetContract() string { + if m != nil { + return m.Contract } - return out, nil + return "" } -func (c *msgClient) RemoveWhitelistedNftContracts(ctx context.Context, in *MsgRemoveWhitelistedNftContracts, opts ...grpc.CallOption) (*MsgRemoveWhitelistedNftContractsResponse, error) { - out := new(MsgRemoveWhitelistedNftContractsResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/RemoveWhitelistedNftContracts", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type EventNftContractRemoveWhitelist struct { + Contract string `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"` } -func (c *msgClient) DepositNft(ctx context.Context, in *MsgDepositNft, opts ...grpc.CallOption) (*MsgDepositNftResponse, error) { - out := new(MsgDepositNftResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/DepositNft", in, out, opts...) - if err != nil { - return nil, err +func (m *EventNftContractRemoveWhitelist) Reset() { *m = EventNftContractRemoveWhitelist{} } +func (m *EventNftContractRemoveWhitelist) String() string { return proto.CompactTextString(m) } +func (*EventNftContractRemoveWhitelist) ProtoMessage() {} +func (*EventNftContractRemoveWhitelist) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{30} +} +func (m *EventNftContractRemoveWhitelist) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventNftContractRemoveWhitelist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventNftContractRemoveWhitelist.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *EventNftContractRemoveWhitelist) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventNftContractRemoveWhitelist.Merge(m, src) +} +func (m *EventNftContractRemoveWhitelist) XXX_Size() int { + return m.Size() +} +func (m *EventNftContractRemoveWhitelist) XXX_DiscardUnknown() { + xxx_messageInfo_EventNftContractRemoveWhitelist.DiscardUnknown(m) } -func (c *msgClient) WithdrawUpdatedNft(ctx context.Context, in *MsgWithdrawUpdatedNft, opts ...grpc.CallOption) (*MsgWithdrawUpdatedNftResponse, error) { - out := new(MsgWithdrawUpdatedNftResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/WithdrawUpdatedNft", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_EventNftContractRemoveWhitelist proto.InternalMessageInfo + +func (m *EventNftContractRemoveWhitelist) GetContract() string { + if m != nil { + return m.Contract } - return out, nil + return "" } -func (c *msgClient) DepositToken(ctx context.Context, in *MsgDepositToken, opts ...grpc.CallOption) (*MsgDepositTokenResponse, error) { - out := new(MsgDepositTokenResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/DepositToken", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type EventDepositNft struct { + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` + Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty"` + TokenId uint64 `protobuf:"varint,3,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` } -func (c *msgClient) WithdrawToken(ctx context.Context, in *MsgWithdrawToken, opts ...grpc.CallOption) (*MsgWithdrawTokenResponse, error) { - out := new(MsgWithdrawTokenResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/WithdrawToken", in, out, opts...) - if err != nil { - return nil, err +func (m *EventDepositNft) Reset() { *m = EventDepositNft{} } +func (m *EventDepositNft) String() string { return proto.CompactTextString(m) } +func (*EventDepositNft) ProtoMessage() {} +func (*EventDepositNft) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{31} +} +func (m *EventDepositNft) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventDepositNft) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventDepositNft.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *EventDepositNft) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventDepositNft.Merge(m, src) +} +func (m *EventDepositNft) XXX_Size() int { + return m.Size() +} +func (m *EventDepositNft) XXX_DiscardUnknown() { + xxx_messageInfo_EventDepositNft.DiscardUnknown(m) } -func (c *msgClient) StakeInGameToken(ctx context.Context, in *MsgStakeInGameToken, opts ...grpc.CallOption) (*MsgStakeInGameTokenResponse, error) { - out := new(MsgStakeInGameTokenResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/StakeInGameToken", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_EventDepositNft proto.InternalMessageInfo + +func (m *EventDepositNft) GetOwner() string { + if m != nil { + return m.Owner } - return out, nil + return "" } -func (c *msgClient) BeginUnstakeInGameToken(ctx context.Context, in *MsgBeginUnstakeInGameToken, opts ...grpc.CallOption) (*MsgBeginUnstakeInGameTokenResponse, error) { - out := new(MsgBeginUnstakeInGameTokenResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/BeginUnstakeInGameToken", in, out, opts...) - if err != nil { - return nil, err +func (m *EventDepositNft) GetContract() string { + if m != nil { + return m.Contract } - return out, nil + return "" } -func (c *msgClient) ClaimInGameStakingReward(ctx context.Context, in *MsgClaimInGameStakingReward, opts ...grpc.CallOption) (*MsgClaimInGameStakingRewardResponse, error) { - out := new(MsgClaimInGameStakingRewardResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/ClaimInGameStakingReward", in, out, opts...) - if err != nil { - return nil, err +func (m *EventDepositNft) GetTokenId() uint64 { + if m != nil { + return m.TokenId } - return out, nil + return 0 } -func (c *msgClient) AddLiquidity(ctx context.Context, in *MsgAddLiquidity, opts ...grpc.CallOption) (*MsgAddLiquidityResponse, error) { - out := new(MsgAddLiquidityResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/AddLiquidity", in, out, opts...) - if err != nil { - return nil, err +type EventWithdrawNft struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty"` + TokenId uint64 `protobuf:"varint,3,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + ExecMsg string `protobuf:"bytes,4,opt,name=exec_msg,json=execMsg,proto3" json:"exec_msg,omitempty"` +} + +func (m *EventWithdrawNft) Reset() { *m = EventWithdrawNft{} } +func (m *EventWithdrawNft) String() string { return proto.CompactTextString(m) } +func (*EventWithdrawNft) ProtoMessage() {} +func (*EventWithdrawNft) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{32} +} +func (m *EventWithdrawNft) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventWithdrawNft) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventWithdrawNft.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *EventWithdrawNft) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventWithdrawNft.Merge(m, src) +} +func (m *EventWithdrawNft) XXX_Size() int { + return m.Size() +} +func (m *EventWithdrawNft) XXX_DiscardUnknown() { + xxx_messageInfo_EventWithdrawNft.DiscardUnknown(m) } -func (c *msgClient) RemoveLiquidity(ctx context.Context, in *MsgRemoveLiquidity, opts ...grpc.CallOption) (*MsgRemoveLiquidityResponse, error) { - out := new(MsgRemoveLiquidityResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/RemoveLiquidity", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_EventWithdrawNft proto.InternalMessageInfo + +func (m *EventWithdrawNft) GetSender() string { + if m != nil { + return m.Sender } - return out, nil + return "" } -func (c *msgClient) Swap(ctx context.Context, in *MsgSwap, opts ...grpc.CallOption) (*MsgSwapResponse, error) { - out := new(MsgSwapResponse) - err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/Swap", in, out, opts...) - if err != nil { - return nil, err +func (m *EventWithdrawNft) GetContract() string { + if m != nil { + return m.Contract } - return out, nil + return "" } -// MsgServer is the server API for Msg service. -type MsgServer interface { - TransferModuleOwnership(context.Context, *MsgTransferModuleOwnership) (*MsgTransferModuleOwnershipResponse, error) - WhitelistNftContracts(context.Context, *MsgWhitelistNftContracts) (*MsgWhitelistNftContractsResponse, error) - RemoveWhitelistedNftContracts(context.Context, *MsgRemoveWhitelistedNftContracts) (*MsgRemoveWhitelistedNftContractsResponse, error) - DepositNft(context.Context, *MsgDepositNft) (*MsgDepositNftResponse, error) - WithdrawUpdatedNft(context.Context, *MsgWithdrawUpdatedNft) (*MsgWithdrawUpdatedNftResponse, error) - DepositToken(context.Context, *MsgDepositToken) (*MsgDepositTokenResponse, error) - WithdrawToken(context.Context, *MsgWithdrawToken) (*MsgWithdrawTokenResponse, error) - StakeInGameToken(context.Context, *MsgStakeInGameToken) (*MsgStakeInGameTokenResponse, error) - BeginUnstakeInGameToken(context.Context, *MsgBeginUnstakeInGameToken) (*MsgBeginUnstakeInGameTokenResponse, error) - ClaimInGameStakingReward(context.Context, *MsgClaimInGameStakingReward) (*MsgClaimInGameStakingRewardResponse, error) - AddLiquidity(context.Context, *MsgAddLiquidity) (*MsgAddLiquidityResponse, error) - RemoveLiquidity(context.Context, *MsgRemoveLiquidity) (*MsgRemoveLiquidityResponse, error) - Swap(context.Context, *MsgSwap) (*MsgSwapResponse, error) +func (m *EventWithdrawNft) GetTokenId() uint64 { + if m != nil { + return m.TokenId + } + return 0 } -// UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { +func (m *EventWithdrawNft) GetExecMsg() string { + if m != nil { + return m.ExecMsg + } + return "" } -func (*UnimplementedMsgServer) TransferModuleOwnership(ctx context.Context, req *MsgTransferModuleOwnership) (*MsgTransferModuleOwnershipResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method TransferModuleOwnership not implemented") +type EventDepositToken struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` } -func (*UnimplementedMsgServer) WhitelistNftContracts(ctx context.Context, req *MsgWhitelistNftContracts) (*MsgWhitelistNftContractsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method WhitelistNftContracts not implemented") + +func (m *EventDepositToken) Reset() { *m = EventDepositToken{} } +func (m *EventDepositToken) String() string { return proto.CompactTextString(m) } +func (*EventDepositToken) ProtoMessage() {} +func (*EventDepositToken) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{33} } -func (*UnimplementedMsgServer) RemoveWhitelistedNftContracts(ctx context.Context, req *MsgRemoveWhitelistedNftContracts) (*MsgRemoveWhitelistedNftContractsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RemoveWhitelistedNftContracts not implemented") +func (m *EventDepositToken) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } -func (*UnimplementedMsgServer) DepositNft(ctx context.Context, req *MsgDepositNft) (*MsgDepositNftResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DepositNft not implemented") +func (m *EventDepositToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventDepositToken.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } -func (*UnimplementedMsgServer) WithdrawUpdatedNft(ctx context.Context, req *MsgWithdrawUpdatedNft) (*MsgWithdrawUpdatedNftResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method WithdrawUpdatedNft not implemented") +func (m *EventDepositToken) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventDepositToken.Merge(m, src) } -func (*UnimplementedMsgServer) DepositToken(ctx context.Context, req *MsgDepositToken) (*MsgDepositTokenResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DepositToken not implemented") +func (m *EventDepositToken) XXX_Size() int { + return m.Size() } -func (*UnimplementedMsgServer) WithdrawToken(ctx context.Context, req *MsgWithdrawToken) (*MsgWithdrawTokenResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method WithdrawToken not implemented") +func (m *EventDepositToken) XXX_DiscardUnknown() { + xxx_messageInfo_EventDepositToken.DiscardUnknown(m) } -func (*UnimplementedMsgServer) StakeInGameToken(ctx context.Context, req *MsgStakeInGameToken) (*MsgStakeInGameTokenResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method StakeInGameToken not implemented") + +var xxx_messageInfo_EventDepositToken proto.InternalMessageInfo + +func (m *EventDepositToken) GetSender() string { + if m != nil { + return m.Sender + } + return "" } -func (*UnimplementedMsgServer) BeginUnstakeInGameToken(ctx context.Context, req *MsgBeginUnstakeInGameToken) (*MsgBeginUnstakeInGameTokenResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method BeginUnstakeInGameToken not implemented") + +func (m *EventDepositToken) GetAmount() string { + if m != nil { + return m.Amount + } + return "" } -func (*UnimplementedMsgServer) ClaimInGameStakingReward(ctx context.Context, req *MsgClaimInGameStakingReward) (*MsgClaimInGameStakingRewardResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ClaimInGameStakingReward not implemented") + +type EventWithdrawToken struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` } -func (*UnimplementedMsgServer) AddLiquidity(ctx context.Context, req *MsgAddLiquidity) (*MsgAddLiquidityResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method AddLiquidity not implemented") + +func (m *EventWithdrawToken) Reset() { *m = EventWithdrawToken{} } +func (m *EventWithdrawToken) String() string { return proto.CompactTextString(m) } +func (*EventWithdrawToken) ProtoMessage() {} +func (*EventWithdrawToken) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{34} } -func (*UnimplementedMsgServer) RemoveLiquidity(ctx context.Context, req *MsgRemoveLiquidity) (*MsgRemoveLiquidityResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RemoveLiquidity not implemented") +func (m *EventWithdrawToken) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } -func (*UnimplementedMsgServer) Swap(ctx context.Context, req *MsgSwap) (*MsgSwapResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Swap not implemented") +func (m *EventWithdrawToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventWithdrawToken.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } - -func RegisterMsgServer(s grpc1.Server, srv MsgServer) { - s.RegisterService(&_Msg_serviceDesc, srv) +func (m *EventWithdrawToken) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventWithdrawToken.Merge(m, src) +} +func (m *EventWithdrawToken) XXX_Size() int { + return m.Size() +} +func (m *EventWithdrawToken) XXX_DiscardUnknown() { + xxx_messageInfo_EventWithdrawToken.DiscardUnknown(m) } -func _Msg_TransferModuleOwnership_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgTransferModuleOwnership) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).TransferModuleOwnership(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/TransferModuleOwnership", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).TransferModuleOwnership(ctx, req.(*MsgTransferModuleOwnership)) +var xxx_messageInfo_EventWithdrawToken proto.InternalMessageInfo + +func (m *EventWithdrawToken) GetSender() string { + if m != nil { + return m.Sender } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_WhitelistNftContracts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgWhitelistNftContracts) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).WhitelistNftContracts(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/WhitelistNftContracts", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).WhitelistNftContracts(ctx, req.(*MsgWhitelistNftContracts)) +func (m *EventWithdrawToken) GetAmount() string { + if m != nil { + return m.Amount } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_RemoveWhitelistedNftContracts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgRemoveWhitelistedNftContracts) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).RemoveWhitelistedNftContracts(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/RemoveWhitelistedNftContracts", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).RemoveWhitelistedNftContracts(ctx, req.(*MsgRemoveWhitelistedNftContracts)) - } - return interceptor(ctx, in, info, handler) +type EventStakeInGameToken struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` } -func _Msg_DepositNft_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDepositNft) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).DepositNft(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/DepositNft", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DepositNft(ctx, req.(*MsgDepositNft)) +func (m *EventStakeInGameToken) Reset() { *m = EventStakeInGameToken{} } +func (m *EventStakeInGameToken) String() string { return proto.CompactTextString(m) } +func (*EventStakeInGameToken) ProtoMessage() {} +func (*EventStakeInGameToken) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{35} +} +func (m *EventStakeInGameToken) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventStakeInGameToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventStakeInGameToken.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return interceptor(ctx, in, info, handler) +} +func (m *EventStakeInGameToken) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventStakeInGameToken.Merge(m, src) +} +func (m *EventStakeInGameToken) XXX_Size() int { + return m.Size() +} +func (m *EventStakeInGameToken) XXX_DiscardUnknown() { + xxx_messageInfo_EventStakeInGameToken.DiscardUnknown(m) } -func _Msg_WithdrawUpdatedNft_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgWithdrawUpdatedNft) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).WithdrawUpdatedNft(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/WithdrawUpdatedNft", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).WithdrawUpdatedNft(ctx, req.(*MsgWithdrawUpdatedNft)) +var xxx_messageInfo_EventStakeInGameToken proto.InternalMessageInfo + +func (m *EventStakeInGameToken) GetSender() string { + if m != nil { + return m.Sender } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_DepositToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDepositToken) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).DepositToken(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/DepositToken", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DepositToken(ctx, req.(*MsgDepositToken)) +func (m *EventStakeInGameToken) GetAmount() string { + if m != nil { + return m.Amount } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_WithdrawToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgWithdrawToken) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).WithdrawToken(ctx, in) +type EventClaimInGameStakingReward struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` + RewardClaimTime uint64 `protobuf:"varint,3,opt,name=reward_claim_time,json=rewardClaimTime,proto3" json:"reward_claim_time,omitempty"` +} + +func (m *EventClaimInGameStakingReward) Reset() { *m = EventClaimInGameStakingReward{} } +func (m *EventClaimInGameStakingReward) String() string { return proto.CompactTextString(m) } +func (*EventClaimInGameStakingReward) ProtoMessage() {} +func (*EventClaimInGameStakingReward) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{36} +} +func (m *EventClaimInGameStakingReward) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventClaimInGameStakingReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventClaimInGameStakingReward.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/WithdrawToken", +} +func (m *EventClaimInGameStakingReward) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventClaimInGameStakingReward.Merge(m, src) +} +func (m *EventClaimInGameStakingReward) XXX_Size() int { + return m.Size() +} +func (m *EventClaimInGameStakingReward) XXX_DiscardUnknown() { + xxx_messageInfo_EventClaimInGameStakingReward.DiscardUnknown(m) +} + +var xxx_messageInfo_EventClaimInGameStakingReward proto.InternalMessageInfo + +func (m *EventClaimInGameStakingReward) GetSender() string { + if m != nil { + return m.Sender } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).WithdrawToken(ctx, req.(*MsgWithdrawToken)) + return "" +} + +func (m *EventClaimInGameStakingReward) GetAmount() string { + if m != nil { + return m.Amount } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_StakeInGameToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgStakeInGameToken) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).StakeInGameToken(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/StakeInGameToken", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).StakeInGameToken(ctx, req.(*MsgStakeInGameToken)) +func (m *EventClaimInGameStakingReward) GetRewardClaimTime() uint64 { + if m != nil { + return m.RewardClaimTime } - return interceptor(ctx, in, info, handler) + return 0 } -func _Msg_BeginUnstakeInGameToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgBeginUnstakeInGameToken) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).BeginUnstakeInGameToken(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/BeginUnstakeInGameToken", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).BeginUnstakeInGameToken(ctx, req.(*MsgBeginUnstakeInGameToken)) - } - return interceptor(ctx, in, info, handler) +type EventBeginUnstakeInGameToken struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` + CompletionTime uint64 `protobuf:"varint,3,opt,name=completion_time,json=completionTime,proto3" json:"completion_time,omitempty"` } -func _Msg_ClaimInGameStakingReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgClaimInGameStakingReward) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).ClaimInGameStakingReward(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/ClaimInGameStakingReward", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).ClaimInGameStakingReward(ctx, req.(*MsgClaimInGameStakingReward)) +func (m *EventBeginUnstakeInGameToken) Reset() { *m = EventBeginUnstakeInGameToken{} } +func (m *EventBeginUnstakeInGameToken) String() string { return proto.CompactTextString(m) } +func (*EventBeginUnstakeInGameToken) ProtoMessage() {} +func (*EventBeginUnstakeInGameToken) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{37} +} +func (m *EventBeginUnstakeInGameToken) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventBeginUnstakeInGameToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventBeginUnstakeInGameToken.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return interceptor(ctx, in, info, handler) +} +func (m *EventBeginUnstakeInGameToken) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventBeginUnstakeInGameToken.Merge(m, src) +} +func (m *EventBeginUnstakeInGameToken) XXX_Size() int { + return m.Size() +} +func (m *EventBeginUnstakeInGameToken) XXX_DiscardUnknown() { + xxx_messageInfo_EventBeginUnstakeInGameToken.DiscardUnknown(m) } -func _Msg_AddLiquidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgAddLiquidity) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).AddLiquidity(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/AddLiquidity", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).AddLiquidity(ctx, req.(*MsgAddLiquidity)) +var xxx_messageInfo_EventBeginUnstakeInGameToken proto.InternalMessageInfo + +func (m *EventBeginUnstakeInGameToken) GetSender() string { + if m != nil { + return m.Sender } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_RemoveLiquidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgRemoveLiquidity) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).RemoveLiquidity(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/RemoveLiquidity", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).RemoveLiquidity(ctx, req.(*MsgRemoveLiquidity)) +func (m *EventBeginUnstakeInGameToken) GetAmount() string { + if m != nil { + return m.Amount } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_Swap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgSwap) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).Swap(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cosmichorizon.coho.game.Msg/Swap", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).Swap(ctx, req.(*MsgSwap)) +func (m *EventBeginUnstakeInGameToken) GetCompletionTime() uint64 { + if m != nil { + return m.CompletionTime } - return interceptor(ctx, in, info, handler) + return 0 } -var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "cosmichorizon.coho.game.Msg", - HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "TransferModuleOwnership", - Handler: _Msg_TransferModuleOwnership_Handler, - }, - { - MethodName: "WhitelistNftContracts", - Handler: _Msg_WhitelistNftContracts_Handler, - }, - { - MethodName: "RemoveWhitelistedNftContracts", - Handler: _Msg_RemoveWhitelistedNftContracts_Handler, - }, - { - MethodName: "DepositNft", - Handler: _Msg_DepositNft_Handler, - }, - { - MethodName: "WithdrawUpdatedNft", - Handler: _Msg_WithdrawUpdatedNft_Handler, - }, - { - MethodName: "DepositToken", - Handler: _Msg_DepositToken_Handler, - }, - { - MethodName: "WithdrawToken", - Handler: _Msg_WithdrawToken_Handler, - }, - { - MethodName: "StakeInGameToken", - Handler: _Msg_StakeInGameToken_Handler, - }, - { - MethodName: "BeginUnstakeInGameToken", - Handler: _Msg_BeginUnstakeInGameToken_Handler, - }, - { - MethodName: "ClaimInGameStakingReward", - Handler: _Msg_ClaimInGameStakingReward_Handler, - }, - { - MethodName: "AddLiquidity", - Handler: _Msg_AddLiquidity_Handler, - }, - { - MethodName: "RemoveLiquidity", - Handler: _Msg_RemoveLiquidity_Handler, - }, - { - MethodName: "Swap", - Handler: _Msg_Swap_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "game/tx.proto", +type EventCompleteUnstakeInGameToken struct { + User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"` + Amount string `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"` + CompletionTime uint64 `protobuf:"varint,3,opt,name=completion_time,json=completionTime,proto3" json:"completion_time,omitempty"` + UnbondingId uint64 `protobuf:"varint,4,opt,name=unbonding_id,json=unbondingId,proto3" json:"unbonding_id,omitempty"` } -func (m *MsgTransferModuleOwnership) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *EventCompleteUnstakeInGameToken) Reset() { *m = EventCompleteUnstakeInGameToken{} } +func (m *EventCompleteUnstakeInGameToken) String() string { return proto.CompactTextString(m) } +func (*EventCompleteUnstakeInGameToken) ProtoMessage() {} +func (*EventCompleteUnstakeInGameToken) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{38} +} +func (m *EventCompleteUnstakeInGameToken) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventCompleteUnstakeInGameToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventCompleteUnstakeInGameToken.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *MsgTransferModuleOwnership) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EventCompleteUnstakeInGameToken) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventCompleteUnstakeInGameToken.Merge(m, src) +} +func (m *EventCompleteUnstakeInGameToken) XXX_Size() int { + return m.Size() +} +func (m *EventCompleteUnstakeInGameToken) XXX_DiscardUnknown() { + xxx_messageInfo_EventCompleteUnstakeInGameToken.DiscardUnknown(m) } -func (m *MsgTransferModuleOwnership) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.NewOwner) > 0 { - i -= len(m.NewOwner) - copy(dAtA[i:], m.NewOwner) - i = encodeVarintTx(dAtA, i, uint64(len(m.NewOwner))) - i-- - dAtA[i] = 0x12 - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa +var xxx_messageInfo_EventCompleteUnstakeInGameToken proto.InternalMessageInfo + +func (m *EventCompleteUnstakeInGameToken) GetUser() string { + if m != nil { + return m.User } - return len(dAtA) - i, nil + return "" } -func (m *MsgTransferModuleOwnershipResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *EventCompleteUnstakeInGameToken) GetAmount() string { + if m != nil { + return m.Amount } - return dAtA[:n], nil + return "" } -func (m *MsgTransferModuleOwnershipResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EventCompleteUnstakeInGameToken) GetCompletionTime() uint64 { + if m != nil { + return m.CompletionTime + } + return 0 } -func (m *MsgTransferModuleOwnershipResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (m *EventCompleteUnstakeInGameToken) GetUnbondingId() uint64 { + if m != nil { + return m.UnbondingId + } + return 0 } -func (m *MsgWhitelistNftContracts) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +type EventAddLiquidity struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Amounts string `protobuf:"bytes,2,opt,name=amounts,proto3" json:"amounts,omitempty"` } -func (m *MsgWhitelistNftContracts) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EventAddLiquidity) Reset() { *m = EventAddLiquidity{} } +func (m *EventAddLiquidity) String() string { return proto.CompactTextString(m) } +func (*EventAddLiquidity) ProtoMessage() {} +func (*EventAddLiquidity) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{39} } - -func (m *MsgWhitelistNftContracts) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Contracts) > 0 { - for iNdEx := len(m.Contracts) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Contracts[iNdEx]) - copy(dAtA[i:], m.Contracts[iNdEx]) - i = encodeVarintTx(dAtA, i, uint64(len(m.Contracts[iNdEx]))) - i-- - dAtA[i] = 0x12 - } - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +func (m *EventAddLiquidity) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (m *MsgWhitelistNftContractsResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *EventAddLiquidity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventAddLiquidity.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *MsgWhitelistNftContractsResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EventAddLiquidity) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventAddLiquidity.Merge(m, src) } - -func (m *MsgWhitelistNftContractsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (m *EventAddLiquidity) XXX_Size() int { + return m.Size() } - -func (m *MsgRemoveWhitelistedNftContracts) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (m *EventAddLiquidity) XXX_DiscardUnknown() { + xxx_messageInfo_EventAddLiquidity.DiscardUnknown(m) } -func (m *MsgRemoveWhitelistedNftContracts) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} +var xxx_messageInfo_EventAddLiquidity proto.InternalMessageInfo -func (m *MsgRemoveWhitelistedNftContracts) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Contracts) > 0 { - for iNdEx := len(m.Contracts) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Contracts[iNdEx]) - copy(dAtA[i:], m.Contracts[iNdEx]) - i = encodeVarintTx(dAtA, i, uint64(len(m.Contracts[iNdEx]))) - i-- - dAtA[i] = 0x12 - } - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa +func (m *EventAddLiquidity) GetSender() string { + if m != nil { + return m.Sender } - return len(dAtA) - i, nil + return "" } -func (m *MsgRemoveWhitelistedNftContractsResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *EventAddLiquidity) GetAmounts() string { + if m != nil { + return m.Amounts } - return dAtA[:n], nil + return "" } -func (m *MsgRemoveWhitelistedNftContractsResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type EventRemoveLiquidity struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + Amounts string `protobuf:"bytes,2,opt,name=amounts,proto3" json:"amounts,omitempty"` } -func (m *MsgRemoveWhitelistedNftContractsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (m *EventRemoveLiquidity) Reset() { *m = EventRemoveLiquidity{} } +func (m *EventRemoveLiquidity) String() string { return proto.CompactTextString(m) } +func (*EventRemoveLiquidity) ProtoMessage() {} +func (*EventRemoveLiquidity) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{40} } - -func (m *MsgDepositNft) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *EventRemoveLiquidity) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventRemoveLiquidity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventRemoveLiquidity.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *MsgDepositNft) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EventRemoveLiquidity) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventRemoveLiquidity.Merge(m, src) +} +func (m *EventRemoveLiquidity) XXX_Size() int { + return m.Size() +} +func (m *EventRemoveLiquidity) XXX_DiscardUnknown() { + xxx_messageInfo_EventRemoveLiquidity.DiscardUnknown(m) } -func (m *MsgDepositNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.TokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) - i-- - dAtA[i] = 0x18 - } - if len(m.Contract) > 0 { - i -= len(m.Contract) - copy(dAtA[i:], m.Contract) - i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) - i-- - dAtA[i] = 0x12 - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa +var xxx_messageInfo_EventRemoveLiquidity proto.InternalMessageInfo + +func (m *EventRemoveLiquidity) GetSender() string { + if m != nil { + return m.Sender } - return len(dAtA) - i, nil + return "" } -func (m *MsgDepositNftResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *EventRemoveLiquidity) GetAmounts() string { + if m != nil { + return m.Amounts } - return dAtA[:n], nil + return "" } -func (m *MsgDepositNftResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type EventSwap struct { + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` + InAmount string `protobuf:"bytes,2,opt,name=in_amount,json=inAmount,proto3" json:"in_amount,omitempty"` + OutAmount string `protobuf:"bytes,3,opt,name=out_amount,json=outAmount,proto3" json:"out_amount,omitempty"` } -func (m *MsgDepositNftResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (m *EventSwap) Reset() { *m = EventSwap{} } +func (m *EventSwap) String() string { return proto.CompactTextString(m) } +func (*EventSwap) ProtoMessage() {} +func (*EventSwap) Descriptor() ([]byte, []int) { + return fileDescriptor_497c523f337df817, []int{41} } - -func (m *TokenInfoExtension) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *EventSwap) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventSwap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventSwap.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *TokenInfoExtension) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EventSwap) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventSwap.Merge(m, src) } - -func (m *TokenInfoExtension) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (m *EventSwap) XXX_Size() int { + return m.Size() +} +func (m *EventSwap) XXX_DiscardUnknown() { + xxx_messageInfo_EventSwap.DiscardUnknown(m) } -func (m *MsgSignerWithdrawUpdatedNft) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_EventSwap proto.InternalMessageInfo + +func (m *EventSwap) GetSender() string { + if m != nil { + return m.Sender } - return dAtA[:n], nil + return "" } -func (m *MsgSignerWithdrawUpdatedNft) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EventSwap) GetInAmount() string { + if m != nil { + return m.InAmount + } + return "" } -func (m *MsgSignerWithdrawUpdatedNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ExecMsg) > 0 { - i -= len(m.ExecMsg) - copy(dAtA[i:], m.ExecMsg) - i = encodeVarintTx(dAtA, i, uint64(len(m.ExecMsg))) - i-- - dAtA[i] = 0x22 - } - if m.TokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) - i-- - dAtA[i] = 0x18 - } - if len(m.Contract) > 0 { - i -= len(m.Contract) - copy(dAtA[i:], m.Contract) - i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) - i-- - dAtA[i] = 0x12 +func (m *EventSwap) GetOutAmount() string { + if m != nil { + return m.OutAmount } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil + return "" } -func (m *MsgWithdrawUpdatedNft) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func init() { + proto.RegisterType((*MsgTransferModuleOwnership)(nil), "cosmichorizon.coho.game.MsgTransferModuleOwnership") + proto.RegisterType((*MsgTransferModuleOwnershipResponse)(nil), "cosmichorizon.coho.game.MsgTransferModuleOwnershipResponse") + proto.RegisterType((*MsgWhitelistNftContracts)(nil), "cosmichorizon.coho.game.MsgWhitelistNftContracts") + proto.RegisterType((*MsgWhitelistNftContractsResponse)(nil), "cosmichorizon.coho.game.MsgWhitelistNftContractsResponse") + proto.RegisterType((*MsgRemoveWhitelistedNftContracts)(nil), "cosmichorizon.coho.game.MsgRemoveWhitelistedNftContracts") + proto.RegisterType((*MsgRemoveWhitelistedNftContractsResponse)(nil), "cosmichorizon.coho.game.MsgRemoveWhitelistedNftContractsResponse") + proto.RegisterType((*MsgDepositNft)(nil), "cosmichorizon.coho.game.MsgDepositNft") + proto.RegisterType((*MsgDepositNftResponse)(nil), "cosmichorizon.coho.game.MsgDepositNftResponse") + proto.RegisterType((*TokenInfoExtension)(nil), "cosmichorizon.coho.game.TokenInfoExtension") + proto.RegisterType((*MsgSignerWithdrawUpdatedNft)(nil), "cosmichorizon.coho.game.MsgSignerWithdrawUpdatedNft") + proto.RegisterType((*MsgWithdrawUpdatedNft)(nil), "cosmichorizon.coho.game.MsgWithdrawUpdatedNft") + proto.RegisterType((*MsgWithdrawUpdatedNftResponse)(nil), "cosmichorizon.coho.game.MsgWithdrawUpdatedNftResponse") + proto.RegisterType((*MsgDepositToken)(nil), "cosmichorizon.coho.game.MsgDepositToken") + proto.RegisterType((*MsgDepositTokenResponse)(nil), "cosmichorizon.coho.game.MsgDepositTokenResponse") + proto.RegisterType((*MsgWithdrawToken)(nil), "cosmichorizon.coho.game.MsgWithdrawToken") + proto.RegisterType((*MsgWithdrawTokenResponse)(nil), "cosmichorizon.coho.game.MsgWithdrawTokenResponse") + proto.RegisterType((*MsgStakeInGameToken)(nil), "cosmichorizon.coho.game.MsgStakeInGameToken") + proto.RegisterType((*MsgStakeInGameTokenResponse)(nil), "cosmichorizon.coho.game.MsgStakeInGameTokenResponse") + proto.RegisterType((*MsgBeginUnstakeInGameToken)(nil), "cosmichorizon.coho.game.MsgBeginUnstakeInGameToken") + proto.RegisterType((*MsgBeginUnstakeInGameTokenResponse)(nil), "cosmichorizon.coho.game.MsgBeginUnstakeInGameTokenResponse") + proto.RegisterType((*MsgClaimInGameStakingReward)(nil), "cosmichorizon.coho.game.MsgClaimInGameStakingReward") + proto.RegisterType((*MsgClaimInGameStakingRewardResponse)(nil), "cosmichorizon.coho.game.MsgClaimInGameStakingRewardResponse") + proto.RegisterType((*MsgAddLiquidity)(nil), "cosmichorizon.coho.game.MsgAddLiquidity") + proto.RegisterType((*MsgAddLiquidityResponse)(nil), "cosmichorizon.coho.game.MsgAddLiquidityResponse") + proto.RegisterType((*MsgRemoveLiquidity)(nil), "cosmichorizon.coho.game.MsgRemoveLiquidity") + proto.RegisterType((*MsgRemoveLiquidityResponse)(nil), "cosmichorizon.coho.game.MsgRemoveLiquidityResponse") + proto.RegisterType((*MsgSwap)(nil), "cosmichorizon.coho.game.MsgSwap") + proto.RegisterType((*MsgSwapResponse)(nil), "cosmichorizon.coho.game.MsgSwapResponse") + proto.RegisterType((*EventTransferModuleOwnership)(nil), "cosmichorizon.coho.game.EventTransferModuleOwnership") + proto.RegisterType((*EventNftContractAddWhitelist)(nil), "cosmichorizon.coho.game.EventNftContractAddWhitelist") + proto.RegisterType((*EventNftContractRemoveWhitelist)(nil), "cosmichorizon.coho.game.EventNftContractRemoveWhitelist") + proto.RegisterType((*EventDepositNft)(nil), "cosmichorizon.coho.game.EventDepositNft") + proto.RegisterType((*EventWithdrawNft)(nil), "cosmichorizon.coho.game.EventWithdrawNft") + proto.RegisterType((*EventDepositToken)(nil), "cosmichorizon.coho.game.EventDepositToken") + proto.RegisterType((*EventWithdrawToken)(nil), "cosmichorizon.coho.game.EventWithdrawToken") + proto.RegisterType((*EventStakeInGameToken)(nil), "cosmichorizon.coho.game.EventStakeInGameToken") + proto.RegisterType((*EventClaimInGameStakingReward)(nil), "cosmichorizon.coho.game.EventClaimInGameStakingReward") + proto.RegisterType((*EventBeginUnstakeInGameToken)(nil), "cosmichorizon.coho.game.EventBeginUnstakeInGameToken") + proto.RegisterType((*EventCompleteUnstakeInGameToken)(nil), "cosmichorizon.coho.game.EventCompleteUnstakeInGameToken") + proto.RegisterType((*EventAddLiquidity)(nil), "cosmichorizon.coho.game.EventAddLiquidity") + proto.RegisterType((*EventRemoveLiquidity)(nil), "cosmichorizon.coho.game.EventRemoveLiquidity") + proto.RegisterType((*EventSwap)(nil), "cosmichorizon.coho.game.EventSwap") } -func (m *MsgWithdrawUpdatedNft) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func init() { proto.RegisterFile("game/tx.proto", fileDescriptor_497c523f337df817) } + +var fileDescriptor_497c523f337df817 = []byte{ + // 1167 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xcf, 0x73, 0xdb, 0x44, + 0x14, 0x8e, 0x1a, 0xb7, 0x89, 0x5f, 0x12, 0x92, 0x88, 0xa4, 0x71, 0x94, 0xc4, 0x31, 0xe2, 0x97, + 0x69, 0x41, 0x26, 0x0d, 0x3f, 0xa6, 0xfc, 0x38, 0x24, 0x69, 0xa6, 0x64, 0x06, 0x43, 0xc7, 0xa4, + 0x53, 0xa6, 0x87, 0x7a, 0x64, 0x69, 0x23, 0x2f, 0x8d, 0x76, 0x8d, 0x76, 0x1d, 0xa7, 0xd0, 0x2b, + 0xc3, 0x81, 0x19, 0x86, 0x2b, 0x07, 0x86, 0xff, 0x86, 0xe9, 0xb1, 0x47, 0x4e, 0x0c, 0x93, 0xfc, + 0x23, 0x8c, 0x76, 0xa5, 0xb5, 0xec, 0x5a, 0x8a, 0x1d, 0x12, 0xb8, 0x79, 0x77, 0xdf, 0xfb, 0xbe, + 0x6f, 0x57, 0x6f, 0xbf, 0x27, 0x19, 0x66, 0x3c, 0xdb, 0x47, 0x15, 0x7e, 0x6c, 0xb5, 0x02, 0xca, + 0xa9, 0xbe, 0xe4, 0x50, 0xe6, 0x63, 0xa7, 0x49, 0x03, 0xfc, 0x1d, 0x25, 0x96, 0x43, 0x9b, 0xd4, + 0x0a, 0x23, 0x8c, 0x62, 0xb8, 0x40, 0x59, 0xa5, 0x61, 0x33, 0x54, 0x39, 0xda, 0x68, 0x20, 0x6e, + 0x6f, 0x54, 0x1c, 0x8a, 0x89, 0x4c, 0x34, 0x16, 0x3c, 0xea, 0x51, 0xf1, 0xb3, 0x12, 0xfe, 0x92, + 0xb3, 0xe6, 0x3d, 0x30, 0xaa, 0xcc, 0xdb, 0x0f, 0x6c, 0xc2, 0x0e, 0x50, 0x50, 0xa5, 0x6e, 0xfb, + 0x10, 0x7d, 0xd9, 0x21, 0x28, 0x60, 0x4d, 0xdc, 0xd2, 0xaf, 0xc3, 0x35, 0x86, 0x88, 0x8b, 0x82, + 0x82, 0x56, 0xd2, 0xca, 0xf9, 0x5a, 0x34, 0xd2, 0x0d, 0x98, 0x24, 0xa8, 0x23, 0xe2, 0x0a, 0x57, + 0xc4, 0x8a, 0x1a, 0x9b, 0xaf, 0x81, 0x99, 0x8e, 0x58, 0x43, 0xac, 0x45, 0x09, 0x43, 0xe6, 0x3d, + 0x28, 0x54, 0x99, 0xf7, 0xa0, 0x89, 0x39, 0x3a, 0xc4, 0x8c, 0x7f, 0x71, 0xc0, 0x77, 0x28, 0xe1, + 0x81, 0xed, 0x70, 0x96, 0xca, 0xba, 0x0a, 0x79, 0x27, 0x0e, 0x2a, 0x5c, 0x29, 0x8d, 0x97, 0xf3, + 0xb5, 0xee, 0x84, 0x69, 0x42, 0x29, 0x0d, 0x51, 0xb1, 0x7e, 0x2d, 0x62, 0x6a, 0xc8, 0xa7, 0x47, + 0x48, 0x45, 0x22, 0xf7, 0x02, 0xd8, 0x6f, 0x40, 0xf9, 0x2c, 0x64, 0xa5, 0xe2, 0x11, 0xcc, 0x54, + 0x99, 0x77, 0x07, 0xb5, 0x28, 0xc3, 0xa1, 0xce, 0xac, 0x63, 0x8e, 0x19, 0xe2, 0x63, 0x8e, 0xc7, + 0xfa, 0x32, 0x4c, 0x72, 0xfa, 0x18, 0x91, 0x3a, 0x76, 0x0b, 0xe3, 0x25, 0xad, 0x9c, 0xab, 0x4d, + 0x88, 0xf1, 0x9e, 0x6b, 0x2e, 0xc1, 0x62, 0x0f, 0xbe, 0x22, 0x5e, 0x00, 0x7d, 0x5f, 0xc4, 0x90, + 0x03, 0xba, 0x7b, 0xcc, 0x11, 0x61, 0x98, 0x12, 0xf3, 0x47, 0x0d, 0x56, 0xaa, 0xcc, 0xfb, 0x0a, + 0x7b, 0x04, 0x05, 0x0f, 0x30, 0x6f, 0xba, 0x81, 0xdd, 0xb9, 0xdf, 0x72, 0x6d, 0xa9, 0xff, 0x82, + 0xd5, 0x85, 0x4b, 0xe8, 0x18, 0x39, 0x75, 0x9f, 0x79, 0x85, 0x9c, 0x48, 0x9b, 0x08, 0xc7, 0x55, + 0xe6, 0x99, 0xbf, 0x6b, 0x42, 0xf9, 0xff, 0xa9, 0x21, 0x7c, 0xcc, 0x0c, 0x7b, 0xc4, 0xe6, 0xed, + 0x00, 0x15, 0xae, 0x96, 0xb4, 0xf2, 0x74, 0xad, 0x3b, 0x61, 0xae, 0xc3, 0xda, 0x40, 0x81, 0xea, + 0x88, 0x1b, 0x30, 0xdb, 0x3d, 0x7b, 0x71, 0xd8, 0xa9, 0xda, 0x3f, 0x84, 0x6b, 0xb6, 0x4f, 0xdb, + 0x44, 0x2a, 0x9f, 0xba, 0xb5, 0x6c, 0xc9, 0x1b, 0x6c, 0x85, 0x37, 0xd8, 0x8a, 0x6e, 0xb0, 0xb5, + 0x43, 0x31, 0xd9, 0xce, 0x3d, 0xfb, 0x6b, 0x7d, 0xac, 0x16, 0x85, 0x9b, 0xcb, 0xb0, 0xd4, 0xc7, + 0xa1, 0xe8, 0x1d, 0x98, 0x4b, 0xe8, 0xbb, 0x24, 0x7e, 0x43, 0xde, 0xdd, 0x24, 0x89, 0x12, 0x70, + 0x00, 0x2f, 0x87, 0xb5, 0xc4, 0xed, 0xc7, 0x68, 0x8f, 0xdc, 0xb5, 0x7d, 0x74, 0x49, 0x1a, 0xd6, + 0x64, 0xcd, 0xf6, 0xf1, 0x28, 0x19, 0xbe, 0xb0, 0xb5, 0x6d, 0xe4, 0x61, 0x72, 0x9f, 0xb0, 0x4b, + 0x57, 0x23, 0x3d, 0x2f, 0x85, 0x4e, 0x89, 0x7a, 0x5f, 0x68, 0xde, 0x39, 0xb4, 0xb1, 0x2f, 0x97, + 0x43, 0xf9, 0x98, 0x78, 0x35, 0xd4, 0xb1, 0x03, 0x37, 0x4d, 0x95, 0xf9, 0x3a, 0xbc, 0x9a, 0x91, + 0xa6, 0xd0, 0x5d, 0x51, 0x79, 0x5b, 0xae, 0xfb, 0x39, 0xfe, 0xb6, 0x8d, 0x5d, 0xcc, 0x9f, 0xa4, + 0xee, 0xf3, 0x36, 0x4c, 0x48, 0xe1, 0xd2, 0xc8, 0x86, 0xd8, 0x68, 0x1c, 0x1f, 0xd5, 0x5e, 0x92, + 0x45, 0x09, 0xf0, 0x40, 0x57, 0x16, 0x78, 0xa9, 0x1a, 0x56, 0xc5, 0xc3, 0xed, 0x23, 0x52, 0x32, + 0x1e, 0xc2, 0x44, 0x58, 0x19, 0x1d, 0xbb, 0x75, 0xf1, 0xcf, 0x79, 0x5e, 0x9c, 0x71, 0x88, 0x9d, + 0x30, 0xf3, 0xd5, 0xdd, 0x23, 0x44, 0x78, 0x5a, 0x0b, 0x7d, 0x05, 0xa6, 0x69, 0x80, 0x3d, 0x4c, + 0xea, 0x54, 0xb4, 0x4b, 0xa9, 0x64, 0x4a, 0xce, 0x89, 0x30, 0x7d, 0x05, 0xf2, 0x04, 0x75, 0xa2, + 0xf5, 0xfe, 0x76, 0xfa, 0x51, 0x84, 0x9f, 0xe8, 0x24, 0x5b, 0xae, 0xab, 0x5a, 0x4c, 0x8f, 0x03, + 0x6a, 0xbd, 0x0e, 0x68, 0x7e, 0x0a, 0xeb, 0xfd, 0xb9, 0x7d, 0x1d, 0x2a, 0x33, 0xfd, 0x11, 0xcc, + 0x8a, 0xf4, 0x44, 0xa7, 0x5a, 0x80, 0xab, 0xc9, 0x6d, 0xc8, 0xc1, 0x79, 0xfb, 0xd4, 0x53, 0x98, + 0x13, 0xf8, 0xb1, 0x93, 0xfc, 0xb7, 0xcd, 0x66, 0x07, 0xe6, 0x93, 0xbb, 0xcb, 0x76, 0x86, 0xeb, + 0x3d, 0x15, 0x93, 0x57, 0x05, 0x71, 0x07, 0xf4, 0x9e, 0x2d, 0x9c, 0x0f, 0xe5, 0x2e, 0x2c, 0x0a, + 0x94, 0xa1, 0x6d, 0x33, 0x0d, 0xe8, 0x7b, 0x58, 0x13, 0x40, 0xa3, 0x7a, 0x4c, 0x1a, 0xa0, 0x7e, + 0x03, 0xe6, 0x03, 0x91, 0x59, 0x77, 0x42, 0xc8, 0x3a, 0xc7, 0x3e, 0x8a, 0xce, 0x78, 0x56, 0x2e, + 0x08, 0xaa, 0x7d, 0xec, 0x23, 0xb3, 0x13, 0x55, 0xea, 0xa8, 0xae, 0x9b, 0xc6, 0xfd, 0x26, 0xcc, + 0x3a, 0xd4, 0x6f, 0x1d, 0x22, 0x8e, 0x29, 0x49, 0x32, 0xbf, 0xd4, 0x9d, 0x16, 0xc4, 0xbf, 0x6a, + 0x51, 0x9d, 0xef, 0xc8, 0x79, 0x34, 0x80, 0x5c, 0x87, 0x5c, 0x9b, 0x29, 0x6a, 0xf1, 0xfb, 0x5f, + 0x13, 0x87, 0x77, 0xbb, 0x4d, 0x1a, 0x94, 0xb8, 0x98, 0x78, 0x61, 0xf1, 0xe5, 0x44, 0xd4, 0x94, + 0x9a, 0xdb, 0x73, 0xcd, 0xdd, 0xa8, 0xca, 0x86, 0xf2, 0xe5, 0x42, 0xd2, 0x13, 0x45, 0xb1, 0xc6, + 0x96, 0xf7, 0x19, 0x2c, 0x08, 0x98, 0x61, 0xdd, 0x35, 0x1d, 0xa9, 0x0e, 0x79, 0x59, 0x6b, 0x59, + 0x06, 0xb9, 0x02, 0x79, 0x4c, 0xea, 0x3d, 0x87, 0x33, 0x89, 0xc9, 0x96, 0x3c, 0x9e, 0x35, 0x00, + 0xda, 0xe6, 0xf1, 0xea, 0xb8, 0x58, 0xcd, 0xd3, 0x36, 0x97, 0xcb, 0xb7, 0xfe, 0x98, 0x86, 0xf1, + 0xf0, 0x45, 0xea, 0x27, 0x0d, 0x96, 0xd2, 0x4c, 0x71, 0xd3, 0x4a, 0xf9, 0x8a, 0xb1, 0xd2, 0x3f, + 0x1d, 0x8c, 0x8f, 0xcf, 0x91, 0x14, 0xdb, 0xb4, 0xfe, 0x83, 0x06, 0x8b, 0x83, 0xbf, 0x36, 0x36, + 0xb2, 0x60, 0x07, 0xa6, 0x18, 0xb7, 0x47, 0x4e, 0x51, 0x3a, 0x7e, 0xd3, 0x60, 0x2d, 0xfb, 0xfb, + 0x23, 0x13, 0x3c, 0x33, 0xd5, 0xd8, 0x3a, 0x77, 0xaa, 0xd2, 0xe7, 0x02, 0x24, 0xec, 0xfe, 0x8d, + 0x2c, 0xc0, 0x6e, 0x9c, 0x61, 0x0d, 0x17, 0xa7, 0x58, 0x9e, 0x82, 0x3e, 0xe0, 0x25, 0x3f, 0x13, + 0xe5, 0xc5, 0x78, 0xe3, 0x83, 0xd1, 0xe2, 0x15, 0xfb, 0x37, 0x30, 0xdd, 0x63, 0xfa, 0xe5, 0x21, + 0xd4, 0x8b, 0x48, 0xe3, 0xdd, 0x61, 0x23, 0x15, 0x97, 0x0f, 0x33, 0xbd, 0xbd, 0xe1, 0xad, 0x61, + 0x44, 0x4b, 0xb6, 0x8d, 0xa1, 0x43, 0x15, 0xdd, 0x11, 0xcc, 0xbd, 0xd0, 0x44, 0xde, 0xce, 0x82, + 0xe9, 0x8f, 0x36, 0xde, 0x1b, 0x25, 0x5a, 0xf1, 0x86, 0x97, 0x3d, 0xcd, 0xf7, 0x33, 0x2f, 0x7b, + 0x4a, 0x52, 0xf6, 0x65, 0x3f, 0xe3, 0x45, 0x5b, 0xff, 0x59, 0x83, 0x42, 0x6a, 0x0b, 0xcc, 0xdc, + 0x60, 0x5a, 0x96, 0xf1, 0xc9, 0x79, 0xb2, 0x92, 0x15, 0xd7, 0xd3, 0x00, 0x32, 0x2b, 0x2e, 0x19, + 0x99, 0x5d, 0x71, 0x83, 0x5e, 0xc3, 0x75, 0x06, 0xb3, 0xfd, 0x5d, 0xe2, 0xe6, 0xd9, 0xbe, 0xd0, + 0x65, 0xdc, 0x1c, 0x21, 0x58, 0x91, 0xd6, 0x20, 0x27, 0x1a, 0x4a, 0x29, 0xb3, 0x7a, 0x3a, 0x76, + 0xcb, 0x28, 0x9f, 0x15, 0x11, 0x63, 0x6e, 0xef, 0x3e, 0x3b, 0x29, 0x6a, 0xcf, 0x4f, 0x8a, 0xda, + 0xdf, 0x27, 0x45, 0xed, 0x97, 0xd3, 0xe2, 0xd8, 0xf3, 0xd3, 0xe2, 0xd8, 0x9f, 0xa7, 0xc5, 0xb1, + 0x87, 0x37, 0x3d, 0xcc, 0x9b, 0xed, 0x86, 0xe5, 0x50, 0xbf, 0x22, 0xd1, 0xde, 0x89, 0xe0, 0x2a, + 0x21, 0x5c, 0xe5, 0xb8, 0x22, 0xff, 0x33, 0x7b, 0xd2, 0x42, 0xac, 0x71, 0x4d, 0xfc, 0xd1, 0xb5, + 0xf9, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x30, 0xbe, 0xcd, 0x1e, 0x48, 0x13, 0x00, 0x00, } -func (m *MsgWithdrawUpdatedNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Signature) > 0 { - i -= len(m.Signature) - copy(dAtA[i:], m.Signature) - i = encodeVarintTx(dAtA, i, uint64(len(m.Signature))) - i-- - dAtA[i] = 0x2a - } - if len(m.ExecMsg) > 0 { - i -= len(m.ExecMsg) - copy(dAtA[i:], m.ExecMsg) - i = encodeVarintTx(dAtA, i, uint64(len(m.ExecMsg))) - i-- - dAtA[i] = 0x22 - } - if m.TokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) - i-- - dAtA[i] = 0x18 - } - if len(m.Contract) > 0 { - i -= len(m.Contract) - copy(dAtA[i:], m.Contract) - i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) - i-- - dAtA[i] = 0x12 - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + TransferModuleOwnership(ctx context.Context, in *MsgTransferModuleOwnership, opts ...grpc.CallOption) (*MsgTransferModuleOwnershipResponse, error) + WhitelistNftContracts(ctx context.Context, in *MsgWhitelistNftContracts, opts ...grpc.CallOption) (*MsgWhitelistNftContractsResponse, error) + RemoveWhitelistedNftContracts(ctx context.Context, in *MsgRemoveWhitelistedNftContracts, opts ...grpc.CallOption) (*MsgRemoveWhitelistedNftContractsResponse, error) + DepositNft(ctx context.Context, in *MsgDepositNft, opts ...grpc.CallOption) (*MsgDepositNftResponse, error) + WithdrawUpdatedNft(ctx context.Context, in *MsgWithdrawUpdatedNft, opts ...grpc.CallOption) (*MsgWithdrawUpdatedNftResponse, error) + DepositToken(ctx context.Context, in *MsgDepositToken, opts ...grpc.CallOption) (*MsgDepositTokenResponse, error) + WithdrawToken(ctx context.Context, in *MsgWithdrawToken, opts ...grpc.CallOption) (*MsgWithdrawTokenResponse, error) + StakeInGameToken(ctx context.Context, in *MsgStakeInGameToken, opts ...grpc.CallOption) (*MsgStakeInGameTokenResponse, error) + BeginUnstakeInGameToken(ctx context.Context, in *MsgBeginUnstakeInGameToken, opts ...grpc.CallOption) (*MsgBeginUnstakeInGameTokenResponse, error) + ClaimInGameStakingReward(ctx context.Context, in *MsgClaimInGameStakingReward, opts ...grpc.CallOption) (*MsgClaimInGameStakingRewardResponse, error) + AddLiquidity(ctx context.Context, in *MsgAddLiquidity, opts ...grpc.CallOption) (*MsgAddLiquidityResponse, error) + RemoveLiquidity(ctx context.Context, in *MsgRemoveLiquidity, opts ...grpc.CallOption) (*MsgRemoveLiquidityResponse, error) + Swap(ctx context.Context, in *MsgSwap, opts ...grpc.CallOption) (*MsgSwapResponse, error) } -func (m *MsgWithdrawUpdatedNftResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) TransferModuleOwnership(ctx context.Context, in *MsgTransferModuleOwnership, opts ...grpc.CallOption) (*MsgTransferModuleOwnershipResponse, error) { + out := new(MsgTransferModuleOwnershipResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/TransferModuleOwnership", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *MsgWithdrawUpdatedNftResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) WhitelistNftContracts(ctx context.Context, in *MsgWhitelistNftContracts, opts ...grpc.CallOption) (*MsgWhitelistNftContractsResponse, error) { + out := new(MsgWhitelistNftContractsResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/WhitelistNftContracts", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *MsgWithdrawUpdatedNftResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (c *msgClient) RemoveWhitelistedNftContracts(ctx context.Context, in *MsgRemoveWhitelistedNftContracts, opts ...grpc.CallOption) (*MsgRemoveWhitelistedNftContractsResponse, error) { + out := new(MsgRemoveWhitelistedNftContractsResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/RemoveWhitelistedNftContracts", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *MsgDepositToken) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) DepositNft(ctx context.Context, in *MsgDepositNft, opts ...grpc.CallOption) (*MsgDepositNftResponse, error) { + out := new(MsgDepositNftResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/DepositNft", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *MsgDepositToken) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) WithdrawUpdatedNft(ctx context.Context, in *MsgWithdrawUpdatedNft, opts ...grpc.CallOption) (*MsgWithdrawUpdatedNftResponse, error) { + out := new(MsgWithdrawUpdatedNftResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/WithdrawUpdatedNft", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *MsgDepositToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa +func (c *msgClient) DepositToken(ctx context.Context, in *MsgDepositToken, opts ...grpc.CallOption) (*MsgDepositTokenResponse, error) { + out := new(MsgDepositTokenResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/DepositToken", in, out, opts...) + if err != nil { + return nil, err } - return len(dAtA) - i, nil + return out, nil } -func (m *MsgDepositTokenResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) WithdrawToken(ctx context.Context, in *MsgWithdrawToken, opts ...grpc.CallOption) (*MsgWithdrawTokenResponse, error) { + out := new(MsgWithdrawTokenResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/WithdrawToken", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *MsgDepositTokenResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) StakeInGameToken(ctx context.Context, in *MsgStakeInGameToken, opts ...grpc.CallOption) (*MsgStakeInGameTokenResponse, error) { + out := new(MsgStakeInGameTokenResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/StakeInGameToken", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *MsgDepositTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (c *msgClient) BeginUnstakeInGameToken(ctx context.Context, in *MsgBeginUnstakeInGameToken, opts ...grpc.CallOption) (*MsgBeginUnstakeInGameTokenResponse, error) { + out := new(MsgBeginUnstakeInGameTokenResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/BeginUnstakeInGameToken", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *MsgWithdrawToken) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) ClaimInGameStakingReward(ctx context.Context, in *MsgClaimInGameStakingReward, opts ...grpc.CallOption) (*MsgClaimInGameStakingRewardResponse, error) { + out := new(MsgClaimInGameStakingRewardResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/ClaimInGameStakingReward", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *MsgWithdrawToken) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) AddLiquidity(ctx context.Context, in *MsgAddLiquidity, opts ...grpc.CallOption) (*MsgAddLiquidityResponse, error) { + out := new(MsgAddLiquidityResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/AddLiquidity", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *MsgWithdrawToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa +func (c *msgClient) RemoveLiquidity(ctx context.Context, in *MsgRemoveLiquidity, opts ...grpc.CallOption) (*MsgRemoveLiquidityResponse, error) { + out := new(MsgRemoveLiquidityResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/RemoveLiquidity", in, out, opts...) + if err != nil { + return nil, err } - return len(dAtA) - i, nil + return out, nil } -func (m *MsgWithdrawTokenResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) Swap(ctx context.Context, in *MsgSwap, opts ...grpc.CallOption) (*MsgSwapResponse, error) { + out := new(MsgSwapResponse) + err := c.cc.Invoke(ctx, "/cosmichorizon.coho.game.Msg/Swap", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *MsgWithdrawTokenResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// MsgServer is the server API for Msg service. +type MsgServer interface { + TransferModuleOwnership(context.Context, *MsgTransferModuleOwnership) (*MsgTransferModuleOwnershipResponse, error) + WhitelistNftContracts(context.Context, *MsgWhitelistNftContracts) (*MsgWhitelistNftContractsResponse, error) + RemoveWhitelistedNftContracts(context.Context, *MsgRemoveWhitelistedNftContracts) (*MsgRemoveWhitelistedNftContractsResponse, error) + DepositNft(context.Context, *MsgDepositNft) (*MsgDepositNftResponse, error) + WithdrawUpdatedNft(context.Context, *MsgWithdrawUpdatedNft) (*MsgWithdrawUpdatedNftResponse, error) + DepositToken(context.Context, *MsgDepositToken) (*MsgDepositTokenResponse, error) + WithdrawToken(context.Context, *MsgWithdrawToken) (*MsgWithdrawTokenResponse, error) + StakeInGameToken(context.Context, *MsgStakeInGameToken) (*MsgStakeInGameTokenResponse, error) + BeginUnstakeInGameToken(context.Context, *MsgBeginUnstakeInGameToken) (*MsgBeginUnstakeInGameTokenResponse, error) + ClaimInGameStakingReward(context.Context, *MsgClaimInGameStakingReward) (*MsgClaimInGameStakingRewardResponse, error) + AddLiquidity(context.Context, *MsgAddLiquidity) (*MsgAddLiquidityResponse, error) + RemoveLiquidity(context.Context, *MsgRemoveLiquidity) (*MsgRemoveLiquidityResponse, error) + Swap(context.Context, *MsgSwap) (*MsgSwapResponse, error) } -func (m *MsgWithdrawTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { } -func (m *MsgStakeInGameToken) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (*UnimplementedMsgServer) TransferModuleOwnership(ctx context.Context, req *MsgTransferModuleOwnership) (*MsgTransferModuleOwnershipResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TransferModuleOwnership not implemented") } - -func (m *MsgStakeInGameToken) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) WhitelistNftContracts(ctx context.Context, req *MsgWhitelistNftContracts) (*MsgWhitelistNftContractsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WhitelistNftContracts not implemented") } - -func (m *MsgStakeInGameToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +func (*UnimplementedMsgServer) RemoveWhitelistedNftContracts(ctx context.Context, req *MsgRemoveWhitelistedNftContracts) (*MsgRemoveWhitelistedNftContractsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveWhitelistedNftContracts not implemented") } - -func (m *MsgStakeInGameTokenResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (*UnimplementedMsgServer) DepositNft(ctx context.Context, req *MsgDepositNft) (*MsgDepositNftResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DepositNft not implemented") } - -func (m *MsgStakeInGameTokenResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) WithdrawUpdatedNft(ctx context.Context, req *MsgWithdrawUpdatedNft) (*MsgWithdrawUpdatedNftResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WithdrawUpdatedNft not implemented") } - -func (m *MsgStakeInGameTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (*UnimplementedMsgServer) DepositToken(ctx context.Context, req *MsgDepositToken) (*MsgDepositTokenResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DepositToken not implemented") } - -func (m *MsgBeginUnstakeInGameToken) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (*UnimplementedMsgServer) WithdrawToken(ctx context.Context, req *MsgWithdrawToken) (*MsgWithdrawTokenResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WithdrawToken not implemented") +} +func (*UnimplementedMsgServer) StakeInGameToken(ctx context.Context, req *MsgStakeInGameToken) (*MsgStakeInGameTokenResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method StakeInGameToken not implemented") +} +func (*UnimplementedMsgServer) BeginUnstakeInGameToken(ctx context.Context, req *MsgBeginUnstakeInGameToken) (*MsgBeginUnstakeInGameTokenResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method BeginUnstakeInGameToken not implemented") +} +func (*UnimplementedMsgServer) ClaimInGameStakingReward(ctx context.Context, req *MsgClaimInGameStakingReward) (*MsgClaimInGameStakingRewardResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClaimInGameStakingReward not implemented") +} +func (*UnimplementedMsgServer) AddLiquidity(ctx context.Context, req *MsgAddLiquidity) (*MsgAddLiquidityResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddLiquidity not implemented") +} +func (*UnimplementedMsgServer) RemoveLiquidity(ctx context.Context, req *MsgRemoveLiquidity) (*MsgRemoveLiquidityResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveLiquidity not implemented") +} +func (*UnimplementedMsgServer) Swap(ctx context.Context, req *MsgSwap) (*MsgSwapResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Swap not implemented") } -func (m *MsgBeginUnstakeInGameToken) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) } -func (m *MsgBeginUnstakeInGameToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) +func _Msg_TransferModuleOwnership_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgTransferModuleOwnership) + if err := dec(in); err != nil { + return nil, err } - i-- - dAtA[i] = 0x12 - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa + if interceptor == nil { + return srv.(MsgServer).TransferModuleOwnership(ctx, in) } - return len(dAtA) - i, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/TransferModuleOwnership", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).TransferModuleOwnership(ctx, req.(*MsgTransferModuleOwnership)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgBeginUnstakeInGameTokenResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_WhitelistNftContracts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgWhitelistNftContracts) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgBeginUnstakeInGameTokenResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgBeginUnstakeInGameTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil + if interceptor == nil { + return srv.(MsgServer).WhitelistNftContracts(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/WhitelistNftContracts", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).WhitelistNftContracts(ctx, req.(*MsgWhitelistNftContracts)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgClaimInGameStakingReward) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_RemoveWhitelistedNftContracts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRemoveWhitelistedNftContracts) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgClaimInGameStakingReward) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).RemoveWhitelistedNftContracts(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/RemoveWhitelistedNftContracts", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RemoveWhitelistedNftContracts(ctx, req.(*MsgRemoveWhitelistedNftContracts)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgClaimInGameStakingReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa +func _Msg_DepositNft_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDepositNft) + if err := dec(in); err != nil { + return nil, err } - return len(dAtA) - i, nil + if interceptor == nil { + return srv.(MsgServer).DepositNft(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/DepositNft", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DepositNft(ctx, req.(*MsgDepositNft)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgClaimInGameStakingRewardResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_WithdrawUpdatedNft_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgWithdrawUpdatedNft) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgClaimInGameStakingRewardResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgClaimInGameStakingRewardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil + if interceptor == nil { + return srv.(MsgServer).WithdrawUpdatedNft(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/WithdrawUpdatedNft", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).WithdrawUpdatedNft(ctx, req.(*MsgWithdrawUpdatedNft)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgAddLiquidity) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_DepositToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDepositToken) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgAddLiquidity) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgAddLiquidity) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Amounts) > 0 { - for iNdEx := len(m.Amounts) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Amounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + if interceptor == nil { + return srv.(MsgServer).DepositToken(ctx, in) } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/DepositToken", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DepositToken(ctx, req.(*MsgDepositToken)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgAddLiquidityResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_WithdrawToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgWithdrawToken) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgAddLiquidityResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).WithdrawToken(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/WithdrawToken", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).WithdrawToken(ctx, req.(*MsgWithdrawToken)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgAddLiquidityResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func _Msg_StakeInGameToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgStakeInGameToken) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).StakeInGameToken(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/StakeInGameToken", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).StakeInGameToken(ctx, req.(*MsgStakeInGameToken)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRemoveLiquidity) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_BeginUnstakeInGameToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgBeginUnstakeInGameToken) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).BeginUnstakeInGameToken(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/BeginUnstakeInGameToken", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).BeginUnstakeInGameToken(ctx, req.(*MsgBeginUnstakeInGameToken)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRemoveLiquidity) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _Msg_ClaimInGameStakingReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgClaimInGameStakingReward) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).ClaimInGameStakingReward(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/ClaimInGameStakingReward", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ClaimInGameStakingReward(ctx, req.(*MsgClaimInGameStakingReward)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRemoveLiquidity) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Amounts) > 0 { - for iNdEx := len(m.Amounts) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Amounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } +func _Msg_AddLiquidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgAddLiquidity) + if err := dec(in); err != nil { + return nil, err } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa + if interceptor == nil { + return srv.(MsgServer).AddLiquidity(ctx, in) } - return len(dAtA) - i, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/AddLiquidity", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).AddLiquidity(ctx, req.(*MsgAddLiquidity)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRemoveLiquidityResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_RemoveLiquidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRemoveLiquidity) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).RemoveLiquidity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/RemoveLiquidity", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RemoveLiquidity(ctx, req.(*MsgRemoveLiquidity)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRemoveLiquidityResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _Msg_Swap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSwap) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Swap(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmichorizon.coho.game.Msg/Swap", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Swap(ctx, req.(*MsgSwap)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRemoveLiquidityResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cosmichorizon.coho.game.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "TransferModuleOwnership", + Handler: _Msg_TransferModuleOwnership_Handler, + }, + { + MethodName: "WhitelistNftContracts", + Handler: _Msg_WhitelistNftContracts_Handler, + }, + { + MethodName: "RemoveWhitelistedNftContracts", + Handler: _Msg_RemoveWhitelistedNftContracts_Handler, + }, + { + MethodName: "DepositNft", + Handler: _Msg_DepositNft_Handler, + }, + { + MethodName: "WithdrawUpdatedNft", + Handler: _Msg_WithdrawUpdatedNft_Handler, + }, + { + MethodName: "DepositToken", + Handler: _Msg_DepositToken_Handler, + }, + { + MethodName: "WithdrawToken", + Handler: _Msg_WithdrawToken_Handler, + }, + { + MethodName: "StakeInGameToken", + Handler: _Msg_StakeInGameToken_Handler, + }, + { + MethodName: "BeginUnstakeInGameToken", + Handler: _Msg_BeginUnstakeInGameToken_Handler, + }, + { + MethodName: "ClaimInGameStakingReward", + Handler: _Msg_ClaimInGameStakingReward_Handler, + }, + { + MethodName: "AddLiquidity", + Handler: _Msg_AddLiquidity_Handler, + }, + { + MethodName: "RemoveLiquidity", + Handler: _Msg_RemoveLiquidity_Handler, + }, + { + MethodName: "Swap", + Handler: _Msg_Swap_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "game/tx.proto", } -func (m *MsgSwap) Marshal() (dAtA []byte, err error) { +func (m *MsgTransferModuleOwnership) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2757,26 +2725,23 @@ func (m *MsgSwap) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSwap) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgTransferModuleOwnership) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSwap) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgTransferModuleOwnership) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) + if len(m.NewOwner) > 0 { + i -= len(m.NewOwner) + copy(dAtA[i:], m.NewOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.NewOwner))) + i-- + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x12 if len(m.Sender) > 0 { i -= len(m.Sender) copy(dAtA[i:], m.Sender) @@ -2787,7 +2752,7 @@ func (m *MsgSwap) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgSwapResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgTransferModuleOwnershipResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2797,12 +2762,12 @@ func (m *MsgSwapResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSwapResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgTransferModuleOwnershipResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSwapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgTransferModuleOwnershipResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2810,403 +2775,3518 @@ func (m *MsgSwapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func encodeVarintTx(dAtA []byte, offset int, v uint64) int { - offset -= sovTx(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *MsgWhitelistNftContracts) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *MsgTransferModuleOwnership) Size() (n int) { - if m == nil { - return 0 - } + +func (m *MsgWhitelistNftContracts) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWhitelistNftContracts) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Contracts) > 0 { + for iNdEx := len(m.Contracts) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Contracts[iNdEx]) + copy(dAtA[i:], m.Contracts[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contracts[iNdEx]))) + i-- + dAtA[i] = 0x12 + } } - l = len(m.NewOwner) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *MsgTransferModuleOwnershipResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgWhitelistNftContractsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgWhitelistNftContractsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWhitelistNftContractsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgWhitelistNftContracts) Size() (n int) { - if m == nil { - return 0 +func (m *MsgRemoveWhitelistedNftContracts) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgRemoveWhitelistedNftContracts) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRemoveWhitelistedNftContracts) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } if len(m.Contracts) > 0 { - for _, s := range m.Contracts { - l = len(s) - n += 1 + l + sovTx(uint64(l)) + for iNdEx := len(m.Contracts) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Contracts[iNdEx]) + copy(dAtA[i:], m.Contracts[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contracts[iNdEx]))) + i-- + dAtA[i] = 0x12 } } - return n + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *MsgWhitelistNftContractsResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgRemoveWhitelistedNftContractsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgRemoveWhitelistedNftContractsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRemoveWhitelistedNftContractsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgRemoveWhitelistedNftContracts) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDepositNft) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if len(m.Contracts) > 0 { - for _, s := range m.Contracts { - l = len(s) - n += 1 + l + sovTx(uint64(l)) - } - } - return n + return dAtA[:n], nil } -func (m *MsgRemoveWhitelistedNftContractsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgDepositNft) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDepositNft) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgDepositNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.TokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) + i-- + dAtA[i] = 0x18 } - l = len(m.Contract) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 } - if m.TokenId != 0 { - n += 1 + sovTx(uint64(m.TokenId)) + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *MsgDepositNftResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDepositNftResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgDepositNftResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDepositNftResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *TokenInfoExtension) Size() (n int) { - if m == nil { - return 0 +func (m *TokenInfoExtension) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *TokenInfoExtension) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TokenInfoExtension) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgSignerWithdrawUpdatedNft) Size() (n int) { - if m == nil { - return 0 +func (m *MsgSignerWithdrawUpdatedNft) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgSignerWithdrawUpdatedNft) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSignerWithdrawUpdatedNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.Contract) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ExecMsg) > 0 { + i -= len(m.ExecMsg) + copy(dAtA[i:], m.ExecMsg) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExecMsg))) + i-- + dAtA[i] = 0x22 } if m.TokenId != 0 { - n += 1 + sovTx(uint64(m.TokenId)) + i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) + i-- + dAtA[i] = 0x18 } - l = len(m.ExecMsg) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 } - return n + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *MsgWithdrawUpdatedNft) Size() (n int) { - if m == nil { - return 0 +func (m *MsgWithdrawUpdatedNft) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgWithdrawUpdatedNft) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawUpdatedNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintTx(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x2a } - l = len(m.Contract) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ExecMsg) > 0 { + i -= len(m.ExecMsg) + copy(dAtA[i:], m.ExecMsg) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExecMsg))) + i-- + dAtA[i] = 0x22 } if m.TokenId != 0 { - n += 1 + sovTx(uint64(m.TokenId)) + i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) + i-- + dAtA[i] = 0x18 } - l = len(m.ExecMsg) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 } - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *MsgWithdrawUpdatedNftResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgWithdrawUpdatedNftResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgDepositToken) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n +func (m *MsgWithdrawUpdatedNftResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDepositTokenResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgWithdrawUpdatedNftResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgWithdrawToken) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) +func (m *MsgDepositToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return dAtA[:n], nil } -func (m *MsgWithdrawTokenResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgDepositToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgStakeInGameToken) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgDepositToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n + i-- + dAtA[i] = 0x12 + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *MsgStakeInGameTokenResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDepositTokenResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgBeginUnstakeInGameToken) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n +func (m *MsgDepositTokenResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgBeginUnstakeInGameTokenResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgDepositTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgClaimInGameStakingReward) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) +func (m *MsgWithdrawToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *MsgClaimInGameStakingRewardResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgWithdrawToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgAddLiquidity) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgWithdrawToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if len(m.Amounts) > 0 { - for _, e := range m.Amounts { - l = e.Size() - n += 1 + l + sovTx(uint64(l)) + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) } - return n + i-- + dAtA[i] = 0x12 + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *MsgAddLiquidityResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgWithdrawTokenResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgWithdrawTokenResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgRemoveLiquidity) Size() (n int) { - if m == nil { - return 0 +func (m *MsgStakeInGameToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgStakeInGameToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgStakeInGameToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if len(m.Amounts) > 0 { - for _, e := range m.Amounts { - l = e.Size() - n += 1 + l + sovTx(uint64(l)) + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) } - return n + i-- + dAtA[i] = 0x12 + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *MsgRemoveLiquidityResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgStakeInGameTokenResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgSwap) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgStakeInGameTokenResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgStakeInGameTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return len(dAtA) - i, nil } -func (m *MsgSwapResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgBeginUnstakeInGameToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MsgBeginUnstakeInGameToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgBeginUnstakeInGameToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func sovTx(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 +func (m *MsgBeginUnstakeInGameTokenResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil } -func sozTx(x uint64) (n int) { - return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + +func (m *MsgBeginUnstakeInGameTokenResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgTransferModuleOwnership) Unmarshal(dAtA []byte) error { + +func (m *MsgBeginUnstakeInGameTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgClaimInGameStakingReward) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgClaimInGameStakingReward) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgClaimInGameStakingReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgClaimInGameStakingRewardResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgClaimInGameStakingRewardResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgClaimInGameStakingRewardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgAddLiquidity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgAddLiquidity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgAddLiquidity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amounts) > 0 { + for iNdEx := len(m.Amounts) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Amounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgAddLiquidityResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgAddLiquidityResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgAddLiquidityResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgRemoveLiquidity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgRemoveLiquidity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRemoveLiquidity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amounts) > 0 { + for iNdEx := len(m.Amounts) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Amounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRemoveLiquidityResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgRemoveLiquidityResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRemoveLiquidityResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgSwap) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSwap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSwap) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgSwapResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSwapResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSwapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *EventTransferModuleOwnership) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventTransferModuleOwnership) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventTransferModuleOwnership) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NewOwner) > 0 { + i -= len(m.NewOwner) + copy(dAtA[i:], m.NewOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.NewOwner))) + i-- + dAtA[i] = 0x12 + } + if len(m.OriginOwner) > 0 { + i -= len(m.OriginOwner) + copy(dAtA[i:], m.OriginOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.OriginOwner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventNftContractAddWhitelist) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventNftContractAddWhitelist) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventNftContractAddWhitelist) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventNftContractRemoveWhitelist) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventNftContractRemoveWhitelist) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventNftContractRemoveWhitelist) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventDepositNft) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventDepositNft) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventDepositNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) + i-- + dAtA[i] = 0x18 + } + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 + } + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintTx(dAtA, i, uint64(len(m.Owner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventWithdrawNft) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventWithdrawNft) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventWithdrawNft) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ExecMsg) > 0 { + i -= len(m.ExecMsg) + copy(dAtA[i:], m.ExecMsg) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExecMsg))) + i-- + dAtA[i] = 0x22 + } + if m.TokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.TokenId)) + i-- + dAtA[i] = 0x18 + } + if len(m.Contract) > 0 { + i -= len(m.Contract) + copy(dAtA[i:], m.Contract) + i = encodeVarintTx(dAtA, i, uint64(len(m.Contract))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventDepositToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventDepositToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventDepositToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventWithdrawToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventWithdrawToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventWithdrawToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventStakeInGameToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventStakeInGameToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventStakeInGameToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventClaimInGameStakingReward) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventClaimInGameStakingReward) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventClaimInGameStakingReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RewardClaimTime != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RewardClaimTime)) + i-- + dAtA[i] = 0x18 + } + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventBeginUnstakeInGameToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBeginUnstakeInGameToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventBeginUnstakeInGameToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CompletionTime != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CompletionTime)) + i-- + dAtA[i] = 0x18 + } + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventCompleteUnstakeInGameToken) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventCompleteUnstakeInGameToken) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventCompleteUnstakeInGameToken) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.UnbondingId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.UnbondingId)) + i-- + dAtA[i] = 0x20 + } + if m.CompletionTime != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CompletionTime)) + i-- + dAtA[i] = 0x18 + } + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0x12 + } + if len(m.User) > 0 { + i -= len(m.User) + copy(dAtA[i:], m.User) + i = encodeVarintTx(dAtA, i, uint64(len(m.User))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventAddLiquidity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventAddLiquidity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventAddLiquidity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amounts) > 0 { + i -= len(m.Amounts) + copy(dAtA[i:], m.Amounts) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amounts))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventRemoveLiquidity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventRemoveLiquidity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventRemoveLiquidity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amounts) > 0 { + i -= len(m.Amounts) + copy(dAtA[i:], m.Amounts) + i = encodeVarintTx(dAtA, i, uint64(len(m.Amounts))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventSwap) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventSwap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventSwap) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.OutAmount) > 0 { + i -= len(m.OutAmount) + copy(dAtA[i:], m.OutAmount) + i = encodeVarintTx(dAtA, i, uint64(len(m.OutAmount))) + i-- + dAtA[i] = 0x1a + } + if len(m.InAmount) > 0 { + i -= len(m.InAmount) + copy(dAtA[i:], m.InAmount) + i = encodeVarintTx(dAtA, i, uint64(len(m.InAmount))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgTransferModuleOwnership) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.NewOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgTransferModuleOwnershipResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgWhitelistNftContracts) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Contracts) > 0 { + for _, s := range m.Contracts { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgWhitelistNftContractsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRemoveWhitelistedNftContracts) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Contracts) > 0 { + for _, s := range m.Contracts { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgRemoveWhitelistedNftContractsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDepositNft) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.TokenId != 0 { + n += 1 + sovTx(uint64(m.TokenId)) + } + return n +} + +func (m *MsgDepositNftResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *TokenInfoExtension) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgSignerWithdrawUpdatedNft) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.TokenId != 0 { + n += 1 + sovTx(uint64(m.TokenId)) + } + l = len(m.ExecMsg) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgWithdrawUpdatedNft) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.TokenId != 0 { + n += 1 + sovTx(uint64(m.TokenId)) + } + l = len(m.ExecMsg) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgWithdrawUpdatedNftResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDepositToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgDepositTokenResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgWithdrawToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgWithdrawTokenResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgStakeInGameToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgStakeInGameTokenResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgBeginUnstakeInGameToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgBeginUnstakeInGameTokenResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgClaimInGameStakingReward) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgClaimInGameStakingRewardResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgAddLiquidity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Amounts) > 0 { + for _, e := range m.Amounts { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgAddLiquidityResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRemoveLiquidity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Amounts) > 0 { + for _, e := range m.Amounts { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgRemoveLiquidityResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgSwap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgSwapResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *EventTransferModuleOwnership) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OriginOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.NewOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventNftContractAddWhitelist) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventNftContractRemoveWhitelist) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventDepositNft) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.TokenId != 0 { + n += 1 + sovTx(uint64(m.TokenId)) + } + return n +} + +func (m *EventWithdrawNft) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Contract) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.TokenId != 0 { + n += 1 + sovTx(uint64(m.TokenId)) + } + l = len(m.ExecMsg) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventDepositToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventWithdrawToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventStakeInGameToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventClaimInGameStakingReward) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.RewardClaimTime != 0 { + n += 1 + sovTx(uint64(m.RewardClaimTime)) + } + return n +} + +func (m *EventBeginUnstakeInGameToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.CompletionTime != 0 { + n += 1 + sovTx(uint64(m.CompletionTime)) + } + return n +} + +func (m *EventCompleteUnstakeInGameToken) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.User) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.CompletionTime != 0 { + n += 1 + sovTx(uint64(m.CompletionTime)) + } + if m.UnbondingId != 0 { + n += 1 + sovTx(uint64(m.UnbondingId)) + } + return n +} + +func (m *EventAddLiquidity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amounts) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventRemoveLiquidity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Amounts) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *EventSwap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.InAmount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.OutAmount) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgTransferModuleOwnership) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgTransferModuleOwnership: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgTransferModuleOwnership: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgTransferModuleOwnershipResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgTransferModuleOwnershipResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgTransferModuleOwnershipResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWhitelistNftContracts) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgWhitelistNftContracts: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWhitelistNftContracts: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contracts", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contracts = append(m.Contracts, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWhitelistNftContractsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgWhitelistNftContractsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWhitelistNftContractsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRemoveWhitelistedNftContracts) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRemoveWhitelistedNftContracts: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRemoveWhitelistedNftContracts: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contracts", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contracts = append(m.Contracts, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRemoveWhitelistedNftContractsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRemoveWhitelistedNftContractsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRemoveWhitelistedNftContractsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDepositNft) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgDepositNft: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDepositNft: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) + } + m.TokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDepositNftResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgDepositNftResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDepositNftResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TokenInfoExtension) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TokenInfoExtension: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TokenInfoExtension: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgSignerWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgSignerWithdrawUpdatedNft: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSignerWithdrawUpdatedNft: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) + } + m.TokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecMsg", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExecMsg = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgWithdrawUpdatedNft: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawUpdatedNft: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) + } + m.TokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecMsg", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExecMsg = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawUpdatedNftResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgWithdrawUpdatedNftResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawUpdatedNftResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDepositToken) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgDepositToken: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDepositToken: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDepositTokenResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgDepositTokenResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDepositTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawToken) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgWithdrawToken: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawToken: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawTokenResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgWithdrawTokenResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgStakeInGameToken) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3229,10 +6309,10 @@ func (m *MsgTransferModuleOwnership) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgTransferModuleOwnership: wiretype end group for non-group") + return fmt.Errorf("proto: MsgStakeInGameToken: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgTransferModuleOwnership: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgStakeInGameToken: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3269,9 +6349,9 @@ func (m *MsgTransferModuleOwnership) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NewOwner", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -3281,23 +6361,24 @@ func (m *MsgTransferModuleOwnership) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.NewOwner = string(dAtA[iNdEx:postIndex]) + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -3320,7 +6401,7 @@ func (m *MsgTransferModuleOwnership) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgTransferModuleOwnershipResponse) Unmarshal(dAtA []byte) error { +func (m *MsgStakeInGameTokenResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3343,10 +6424,10 @@ func (m *MsgTransferModuleOwnershipResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgTransferModuleOwnershipResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgStakeInGameTokenResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgTransferModuleOwnershipResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgStakeInGameTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -3370,7 +6451,7 @@ func (m *MsgTransferModuleOwnershipResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgWhitelistNftContracts) Unmarshal(dAtA []byte) error { +func (m *MsgBeginUnstakeInGameToken) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3393,10 +6474,10 @@ func (m *MsgWhitelistNftContracts) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgWhitelistNftContracts: wiretype end group for non-group") + return fmt.Errorf("proto: MsgBeginUnstakeInGameToken: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWhitelistNftContracts: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgBeginUnstakeInGameToken: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3433,9 +6514,9 @@ func (m *MsgWhitelistNftContracts) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Contracts", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -3445,23 +6526,24 @@ func (m *MsgWhitelistNftContracts) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.Contracts = append(m.Contracts, string(dAtA[iNdEx:postIndex])) + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -3484,7 +6566,7 @@ func (m *MsgWhitelistNftContracts) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgWhitelistNftContractsResponse) Unmarshal(dAtA []byte) error { +func (m *MsgBeginUnstakeInGameTokenResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3507,10 +6589,10 @@ func (m *MsgWhitelistNftContractsResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgWhitelistNftContractsResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgBeginUnstakeInGameTokenResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWhitelistNftContractsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgBeginUnstakeInGameTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -3534,7 +6616,7 @@ func (m *MsgWhitelistNftContractsResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRemoveWhitelistedNftContracts) Unmarshal(dAtA []byte) error { +func (m *MsgClaimInGameStakingReward) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3557,10 +6639,10 @@ func (m *MsgRemoveWhitelistedNftContracts) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRemoveWhitelistedNftContracts: wiretype end group for non-group") + return fmt.Errorf("proto: MsgClaimInGameStakingReward: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRemoveWhitelistedNftContracts: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgClaimInGameStakingReward: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3595,38 +6677,6 @@ func (m *MsgRemoveWhitelistedNftContracts) Unmarshal(dAtA []byte) error { } m.Sender = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Contracts", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Contracts = append(m.Contracts, string(dAtA[iNdEx:postIndex])) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -3648,7 +6698,7 @@ func (m *MsgRemoveWhitelistedNftContracts) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRemoveWhitelistedNftContractsResponse) Unmarshal(dAtA []byte) error { +func (m *MsgClaimInGameStakingRewardResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3671,10 +6721,10 @@ func (m *MsgRemoveWhitelistedNftContractsResponse) Unmarshal(dAtA []byte) error fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRemoveWhitelistedNftContractsResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgClaimInGameStakingRewardResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRemoveWhitelistedNftContractsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgClaimInGameStakingRewardResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -3698,7 +6748,7 @@ func (m *MsgRemoveWhitelistedNftContractsResponse) Unmarshal(dAtA []byte) error } return nil } -func (m *MsgDepositNft) Unmarshal(dAtA []byte) error { +func (m *MsgAddLiquidity) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3721,10 +6771,10 @@ func (m *MsgDepositNft) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDepositNft: wiretype end group for non-group") + return fmt.Errorf("proto: MsgAddLiquidity: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDepositNft: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgAddLiquidity: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3761,9 +6811,9 @@ func (m *MsgDepositNft) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Amounts", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -3773,43 +6823,76 @@ func (m *MsgDepositNft) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.Contract = string(dAtA[iNdEx:postIndex]) + m.Amounts = append(m.Amounts, types.Coin{}) + if err := m.Amounts[len(m.Amounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err } - m.TokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.TokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgAddLiquidityResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgAddLiquidityResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgAddLiquidityResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -3831,7 +6914,7 @@ func (m *MsgDepositNft) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDepositNftResponse) Unmarshal(dAtA []byte) error { +func (m *MsgRemoveLiquidity) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3841,25 +6924,91 @@ func (m *MsgDepositNftResponse) Unmarshal(dAtA []byte) error { if shift >= 64 { return ErrIntOverflowTx } - if iNdEx >= l { + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRemoveLiquidity: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRemoveLiquidity: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amounts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.Amounts = append(m.Amounts, types.Coin{}) + if err := m.Amounts[len(m.Amounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgDepositNftResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDepositNftResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -3881,7 +7030,7 @@ func (m *MsgDepositNftResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *TokenInfoExtension) Unmarshal(dAtA []byte) error { +func (m *MsgRemoveLiquidityResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3904,10 +7053,10 @@ func (m *TokenInfoExtension) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TokenInfoExtension: wiretype end group for non-group") + return fmt.Errorf("proto: MsgRemoveLiquidityResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TokenInfoExtension: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgRemoveLiquidityResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -3931,7 +7080,7 @@ func (m *TokenInfoExtension) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSignerWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { +func (m *MsgSwap) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3954,10 +7103,10 @@ func (m *MsgSignerWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSignerWithdrawUpdatedNft: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSwap: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSignerWithdrawUpdatedNft: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSwap: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3994,9 +7143,9 @@ func (m *MsgSignerWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -4006,75 +7155,75 @@ func (m *MsgSignerWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.Contract = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) - } - m.TokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.TokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExecMsg", wireType) + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err } - intStringLen := int(stringLen) - if intStringLen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTx + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgSwapResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.ExecMsg = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgSwapResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSwapResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -4096,7 +7245,7 @@ func (m *MsgSignerWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { +func (m *EventTransferModuleOwnership) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4119,15 +7268,15 @@ func (m *MsgWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgWithdrawUpdatedNft: wiretype end group for non-group") + return fmt.Errorf("proto: EventTransferModuleOwnership: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWithdrawUpdatedNft: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventTransferModuleOwnership: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field OriginOwner", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4155,11 +7304,11 @@ func (m *MsgWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Sender = string(dAtA[iNdEx:postIndex]) + m.OriginOwner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NewOwner", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4187,30 +7336,61 @@ func (m *MsgWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Contract = string(dAtA[iNdEx:postIndex]) + m.NewOwner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err } - m.TokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.TokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx } - case 4: + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventNftContractAddWhitelist) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventNftContractAddWhitelist: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventNftContractAddWhitelist: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExecMsg", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4235,44 +7415,10 @@ func (m *MsgWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { if postIndex < 0 { return ErrInvalidLengthTx } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ExecMsg = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} + if postIndex > l { + return io.ErrUnexpectedEOF } + m.Contract = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -4295,7 +7441,7 @@ func (m *MsgWithdrawUpdatedNft) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgWithdrawUpdatedNftResponse) Unmarshal(dAtA []byte) error { +func (m *EventNftContractRemoveWhitelist) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4318,12 +7464,44 @@ func (m *MsgWithdrawUpdatedNftResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgWithdrawUpdatedNftResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EventNftContractRemoveWhitelist: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWithdrawUpdatedNftResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventNftContractRemoveWhitelist: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -4345,7 +7523,7 @@ func (m *MsgWithdrawUpdatedNftResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDepositToken) Unmarshal(dAtA []byte) error { +func (m *EventDepositNft) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4368,15 +7546,15 @@ func (m *MsgDepositToken) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDepositToken: wiretype end group for non-group") + return fmt.Errorf("proto: EventDepositNft: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDepositToken: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventDepositNft: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4404,13 +7582,13 @@ func (m *MsgDepositToken) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Sender = string(dAtA[iNdEx:postIndex]) + m.Owner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -4420,75 +7598,43 @@ func (m *MsgDepositToken) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Contract = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTx - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MsgDepositTokenResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.TokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgDepositTokenResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDepositTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -4510,7 +7656,7 @@ func (m *MsgDepositTokenResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgWithdrawToken) Unmarshal(dAtA []byte) error { +func (m *EventWithdrawNft) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4533,10 +7679,10 @@ func (m *MsgWithdrawToken) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgWithdrawToken: wiretype end group for non-group") + return fmt.Errorf("proto: EventWithdrawNft: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWithdrawToken: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventWithdrawNft: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -4573,9 +7719,9 @@ func (m *MsgWithdrawToken) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -4585,24 +7731,74 @@ func (m *MsgWithdrawToken) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Contract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType) + } + m.TokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecMsg", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF } + m.ExecMsg = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -4625,7 +7821,7 @@ func (m *MsgWithdrawToken) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgWithdrawTokenResponse) Unmarshal(dAtA []byte) error { +func (m *EventDepositToken) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4648,12 +7844,76 @@ func (m *MsgWithdrawTokenResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgWithdrawTokenResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EventDepositToken: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWithdrawTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventDepositToken: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Amount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -4675,7 +7935,7 @@ func (m *MsgWithdrawTokenResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgStakeInGameToken) Unmarshal(dAtA []byte) error { +func (m *EventWithdrawToken) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4698,10 +7958,10 @@ func (m *MsgStakeInGameToken) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgStakeInGameToken: wiretype end group for non-group") + return fmt.Errorf("proto: EventWithdrawToken: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgStakeInGameToken: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventWithdrawToken: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -4740,7 +8000,7 @@ func (m *MsgStakeInGameToken) Unmarshal(dAtA []byte) error { if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -4750,24 +8010,23 @@ func (m *MsgStakeInGameToken) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Amount = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -4790,7 +8049,7 @@ func (m *MsgStakeInGameToken) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgStakeInGameTokenResponse) Unmarshal(dAtA []byte) error { +func (m *EventStakeInGameToken) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4813,12 +8072,76 @@ func (m *MsgStakeInGameTokenResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgStakeInGameTokenResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EventStakeInGameToken: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgStakeInGameTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventStakeInGameToken: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Amount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -4840,7 +8163,7 @@ func (m *MsgStakeInGameTokenResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgBeginUnstakeInGameToken) Unmarshal(dAtA []byte) error { +func (m *EventClaimInGameStakingReward) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4863,10 +8186,10 @@ func (m *MsgBeginUnstakeInGameToken) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgBeginUnstakeInGameToken: wiretype end group for non-group") + return fmt.Errorf("proto: EventClaimInGameStakingReward: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgBeginUnstakeInGameToken: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventClaimInGameStakingReward: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -4905,7 +8228,7 @@ func (m *MsgBeginUnstakeInGameToken) Unmarshal(dAtA []byte) error { if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -4915,25 +8238,43 @@ func (m *MsgBeginUnstakeInGameToken) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Amount = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RewardClaimTime", wireType) + } + m.RewardClaimTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RewardClaimTime |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -4955,7 +8296,7 @@ func (m *MsgBeginUnstakeInGameToken) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgBeginUnstakeInGameTokenResponse) Unmarshal(dAtA []byte) error { +func (m *EventBeginUnstakeInGameToken) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4978,12 +8319,95 @@ func (m *MsgBeginUnstakeInGameTokenResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgBeginUnstakeInGameTokenResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EventBeginUnstakeInGameToken: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgBeginUnstakeInGameTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventBeginUnstakeInGameToken: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Amount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType) + } + m.CompletionTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompletionTime |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -5005,7 +8429,7 @@ func (m *MsgBeginUnstakeInGameTokenResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgClaimInGameStakingReward) Unmarshal(dAtA []byte) error { +func (m *EventCompleteUnstakeInGameToken) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5028,15 +8452,15 @@ func (m *MsgClaimInGameStakingReward) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgClaimInGameStakingReward: wiretype end group for non-group") + return fmt.Errorf("proto: EventCompleteUnstakeInGameToken: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgClaimInGameStakingReward: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventCompleteUnstakeInGameToken: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -5064,58 +8488,78 @@ func (m *MsgClaimInGameStakingReward) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Sender = string(dAtA[iNdEx:postIndex]) + m.User = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - if (iNdEx + skippy) > l { + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MsgClaimInGameStakingRewardResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx + m.Amount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType) + } + m.CompletionTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompletionTime |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingId", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.UnbondingId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UnbondingId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgClaimInGameStakingRewardResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgClaimInGameStakingRewardResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -5137,7 +8581,7 @@ func (m *MsgClaimInGameStakingRewardResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgAddLiquidity) Unmarshal(dAtA []byte) error { +func (m *EventAddLiquidity) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5160,10 +8604,10 @@ func (m *MsgAddLiquidity) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgAddLiquidity: wiretype end group for non-group") + return fmt.Errorf("proto: EventAddLiquidity: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgAddLiquidity: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventAddLiquidity: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -5202,7 +8646,7 @@ func (m *MsgAddLiquidity) Unmarshal(dAtA []byte) error { if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Amounts", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -5212,25 +8656,23 @@ func (m *MsgAddLiquidity) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.Amounts = append(m.Amounts, types.Coin{}) - if err := m.Amounts[len(m.Amounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Amounts = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -5253,57 +8695,7 @@ func (m *MsgAddLiquidity) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgAddLiquidityResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgAddLiquidityResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgAddLiquidityResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTx - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MsgRemoveLiquidity) Unmarshal(dAtA []byte) error { +func (m *EventRemoveLiquidity) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5326,10 +8718,10 @@ func (m *MsgRemoveLiquidity) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRemoveLiquidity: wiretype end group for non-group") + return fmt.Errorf("proto: EventRemoveLiquidity: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRemoveLiquidity: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventRemoveLiquidity: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -5368,7 +8760,7 @@ func (m *MsgRemoveLiquidity) Unmarshal(dAtA []byte) error { if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Amounts", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -5378,25 +8770,23 @@ func (m *MsgRemoveLiquidity) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.Amounts = append(m.Amounts, types.Coin{}) - if err := m.Amounts[len(m.Amounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Amounts = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -5419,57 +8809,7 @@ func (m *MsgRemoveLiquidity) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRemoveLiquidityResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgRemoveLiquidityResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRemoveLiquidityResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTx - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MsgSwap) Unmarshal(dAtA []byte) error { +func (m *EventSwap) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5492,10 +8832,10 @@ func (m *MsgSwap) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSwap: wiretype end group for non-group") + return fmt.Errorf("proto: EventSwap: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSwap: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EventSwap: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -5532,9 +8872,9 @@ func (m *MsgSwap) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InAmount", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -5544,75 +8884,56 @@ func (m *MsgSwap) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.InAmount = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutAmount", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTx + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MsgSwapResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgSwapResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSwapResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { + m.OutAmount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:])