diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index b1c5590..09f3d58 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -47404,6 +47404,11 @@ definitions: type: string highestBid: type: string + cosmostest.cosmostest.MsgNewAuctionResponse: + type: object + properties: + auctionId: + type: string cosmostest.cosmostest.NextAuction: type: object properties: diff --git a/go.mod b/go.mod index 34747d9..2fc1a6f 100644 --- a/go.mod +++ b/go.mod @@ -75,7 +75,6 @@ require ( github.com/goccy/go-yaml v1.9.4 // indirect github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect github.com/gogo/gateway v1.1.0 // indirect - github.com/golang/glog v1.0.0 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/snappy v0.0.3 // indirect github.com/google/btree v1.0.0 // indirect @@ -84,7 +83,6 @@ require ( github.com/gorilla/handlers v1.5.1 // indirect github.com/gorilla/websocket v1.5.0 // indirect github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect - github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3 // indirect github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect github.com/gtank/merlin v0.1.1 // indirect github.com/gtank/ristretto255 v0.1.2 // indirect diff --git a/go.sum b/go.sum index e6eb930..91a334c 100644 --- a/go.sum +++ b/go.sum @@ -600,8 +600,6 @@ github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2V github.com/golang-sql/sqlexp v0.0.0-20170517235910-f1bb20e5a188/go.mod h1:vXjM/+wXQnTPR4KqTKDgJukSZ6amVRtWMPEjE6sQoK8= github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/glog v1.0.0 h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ= -github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -729,8 +727,6 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3 h1:lLT7ZLSzGLI08vc9cpd+tYmNWjdKDqyr/2L+f6U12Fk= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0= github.com/gtank/merlin v0.1.1-0.20191105220539-8318aed1a79f/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= diff --git a/proto/cosmostest/tx.proto b/proto/cosmostest/tx.proto index 7b3c4c2..cd33f1f 100644 --- a/proto/cosmostest/tx.proto +++ b/proto/cosmostest/tx.proto @@ -7,7 +7,19 @@ option go_package = "cosmos-test/x/cosmostest/types"; // Msg defines the Msg service. service Msg { - // this line is used by starport scaffolding # proto/tx/rpc + rpc NewAuction(MsgNewAuction) returns (MsgNewAuctionResponse); +// this line is used by starport scaffolding # proto/tx/rpc +} + +message MsgNewAuction { + string creator = 1; + string owner = 2; + string name = 3; + string description = 4; +} + +message MsgNewAuctionResponse { + string auctionId = 1; } // this line is used by starport scaffolding # proto/tx/message diff --git a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/index.ts b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/index.ts index 34392e7..0a0a876 100755 --- a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/index.ts +++ b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/index.ts @@ -230,7 +230,35 @@ export default { }, + async sendMsgNewAuction({ rootGetters }, { value, fee = [], memo = '' }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgNewAuction(value) + const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, + gas: "200000" }, memo}) + return result + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgNewAuction:Init Could not initialize signing client. Wallet is required.') + }else{ + throw new Error('TxClient:MsgNewAuction:Send Could not broadcast Tx: '+ e.message) + } + } + }, + async MsgNewAuction({ rootGetters }, { value }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgNewAuction(value) + return msg + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgNewAuction:Init Could not initialize signing client. Wallet is required.') + } else{ + throw new Error('TxClient:MsgNewAuction:Create Could not create message: ' + e.message) + } + } + }, } } diff --git a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/index.ts b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/index.ts index 67d4b09..b5114cb 100755 --- a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/index.ts +++ b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/index.ts @@ -4,9 +4,11 @@ import { StdFee } from "@cosmjs/launchpad"; import { SigningStargateClient } from "@cosmjs/stargate"; import { Registry, OfflineSigner, EncodeObject, DirectSecp256k1HdWallet } from "@cosmjs/proto-signing"; import { Api } from "./rest"; +import { MsgNewAuction } from "./types/cosmostest/tx"; const types = [ + ["/cosmostest.cosmostest.MsgNewAuction", MsgNewAuction], ]; export const MissingWalletError = new Error("wallet is required"); @@ -39,6 +41,7 @@ const txClient = async (wallet: OfflineSigner, { addr: addr }: TxClientOptions = return { signAndBroadcast: (msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions = {fee: defaultFee, memo: ""}) => client.signAndBroadcast(address, msgs, fee,memo), + msgNewAuction: (data: MsgNewAuction): EncodeObject => ({ typeUrl: "/cosmostest.cosmostest.MsgNewAuction", value: MsgNewAuction.fromPartial( data ) }), }; }; diff --git a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/rest.ts b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/rest.ts index 09fb37c..2a8ac07 100644 --- a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/rest.ts +++ b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/rest.ts @@ -17,6 +17,10 @@ export interface CosmostestAuction { highestBid?: string; } +export interface CosmostestMsgNewAuctionResponse { + auctionId?: string; +} + export interface CosmostestNextAuction { /** @format uint64 */ auctionId?: string; @@ -106,6 +110,13 @@ export interface V1Beta1PageRequest { * is set. */ count_total?: boolean; + + /** + * reverse is set to true if results are to be returned in the descending order. + * + * Since: cosmos-sdk 0.43 + */ + reverse?: boolean; } /** @@ -335,6 +346,7 @@ export class Api extends HttpClient diff --git a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmos/base/query/v1beta1/pagination.ts b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmos/base/query/v1beta1/pagination.ts index 0bc568f..9c87ac0 100644 --- a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmos/base/query/v1beta1/pagination.ts +++ b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmos/base/query/v1beta1/pagination.ts @@ -38,6 +38,12 @@ export interface PageRequest { * is set. */ count_total: boolean; + /** + * reverse is set to true if results are to be returned in the descending order. + * + * Since: cosmos-sdk 0.43 + */ + reverse: boolean; } /** @@ -62,7 +68,12 @@ export interface PageResponse { total: number; } -const basePageRequest: object = { offset: 0, limit: 0, count_total: false }; +const basePageRequest: object = { + offset: 0, + limit: 0, + count_total: false, + reverse: false, +}; export const PageRequest = { encode(message: PageRequest, writer: Writer = Writer.create()): Writer { @@ -78,6 +89,9 @@ export const PageRequest = { if (message.count_total === true) { writer.uint32(32).bool(message.count_total); } + if (message.reverse === true) { + writer.uint32(40).bool(message.reverse); + } return writer; }, @@ -100,6 +114,9 @@ export const PageRequest = { case 4: message.count_total = reader.bool(); break; + case 5: + message.reverse = reader.bool(); + break; default: reader.skipType(tag & 7); break; @@ -128,6 +145,11 @@ export const PageRequest = { } else { message.count_total = false; } + if (object.reverse !== undefined && object.reverse !== null) { + message.reverse = Boolean(object.reverse); + } else { + message.reverse = false; + } return message; }, @@ -141,6 +163,7 @@ export const PageRequest = { message.limit !== undefined && (obj.limit = message.limit); message.count_total !== undefined && (obj.count_total = message.count_total); + message.reverse !== undefined && (obj.reverse = message.reverse); return obj; }, @@ -166,6 +189,11 @@ export const PageRequest = { } else { message.count_total = false; } + if (object.reverse !== undefined && object.reverse !== null) { + message.reverse = object.reverse; + } else { + message.reverse = false; + } return message; }, }; diff --git a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmostest/tx.ts b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmostest/tx.ts index e18c366..75bfb2a 100644 --- a/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmostest/tx.ts +++ b/vue/src/store/generated/cosmos-test/cosmostest.cosmostest/module/types/cosmostest/tx.ts @@ -1,14 +1,213 @@ /* eslint-disable */ +import { Reader, Writer } from "protobufjs/minimal"; + export const protobufPackage = "cosmostest.cosmostest"; +export interface MsgNewAuction { + creator: string; + owner: string; + name: string; + description: string; +} + +export interface MsgNewAuctionResponse { + auctionId: string; +} + +const baseMsgNewAuction: object = { + creator: "", + owner: "", + name: "", + description: "", +}; + +export const MsgNewAuction = { + encode(message: MsgNewAuction, writer: Writer = Writer.create()): Writer { + if (message.creator !== "") { + writer.uint32(10).string(message.creator); + } + if (message.owner !== "") { + writer.uint32(18).string(message.owner); + } + if (message.name !== "") { + writer.uint32(26).string(message.name); + } + if (message.description !== "") { + writer.uint32(34).string(message.description); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgNewAuction { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgNewAuction } as MsgNewAuction; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.creator = reader.string(); + break; + case 2: + message.owner = reader.string(); + break; + case 3: + message.name = reader.string(); + break; + case 4: + message.description = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgNewAuction { + const message = { ...baseMsgNewAuction } as MsgNewAuction; + if (object.creator !== undefined && object.creator !== null) { + message.creator = String(object.creator); + } else { + message.creator = ""; + } + if (object.owner !== undefined && object.owner !== null) { + message.owner = String(object.owner); + } else { + message.owner = ""; + } + if (object.name !== undefined && object.name !== null) { + message.name = String(object.name); + } else { + message.name = ""; + } + if (object.description !== undefined && object.description !== null) { + message.description = String(object.description); + } else { + message.description = ""; + } + return message; + }, + + toJSON(message: MsgNewAuction): unknown { + const obj: any = {}; + message.creator !== undefined && (obj.creator = message.creator); + message.owner !== undefined && (obj.owner = message.owner); + message.name !== undefined && (obj.name = message.name); + message.description !== undefined && + (obj.description = message.description); + return obj; + }, + + fromPartial(object: DeepPartial): MsgNewAuction { + const message = { ...baseMsgNewAuction } as MsgNewAuction; + if (object.creator !== undefined && object.creator !== null) { + message.creator = object.creator; + } else { + message.creator = ""; + } + if (object.owner !== undefined && object.owner !== null) { + message.owner = object.owner; + } else { + message.owner = ""; + } + if (object.name !== undefined && object.name !== null) { + message.name = object.name; + } else { + message.name = ""; + } + if (object.description !== undefined && object.description !== null) { + message.description = object.description; + } else { + message.description = ""; + } + return message; + }, +}; + +const baseMsgNewAuctionResponse: object = { auctionId: "" }; + +export const MsgNewAuctionResponse = { + encode( + message: MsgNewAuctionResponse, + writer: Writer = Writer.create() + ): Writer { + if (message.auctionId !== "") { + writer.uint32(10).string(message.auctionId); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgNewAuctionResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgNewAuctionResponse } as MsgNewAuctionResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.auctionId = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgNewAuctionResponse { + const message = { ...baseMsgNewAuctionResponse } as MsgNewAuctionResponse; + if (object.auctionId !== undefined && object.auctionId !== null) { + message.auctionId = String(object.auctionId); + } else { + message.auctionId = ""; + } + return message; + }, + + toJSON(message: MsgNewAuctionResponse): unknown { + const obj: any = {}; + message.auctionId !== undefined && (obj.auctionId = message.auctionId); + return obj; + }, + + fromPartial( + object: DeepPartial + ): MsgNewAuctionResponse { + const message = { ...baseMsgNewAuctionResponse } as MsgNewAuctionResponse; + if (object.auctionId !== undefined && object.auctionId !== null) { + message.auctionId = object.auctionId; + } else { + message.auctionId = ""; + } + return message; + }, +}; + /** Msg defines the Msg service. */ -export interface Msg {} +export interface Msg { + /** this line is used by starport scaffolding # proto/tx/rpc */ + NewAuction(request: MsgNewAuction): Promise; +} export class MsgClientImpl implements Msg { private readonly rpc: Rpc; constructor(rpc: Rpc) { this.rpc = rpc; } + NewAuction(request: MsgNewAuction): Promise { + const data = MsgNewAuction.encode(request).finish(); + const promise = this.rpc.request( + "cosmostest.cosmostest.Msg", + "NewAuction", + data + ); + return promise.then((data) => + MsgNewAuctionResponse.decode(new Reader(data)) + ); + } } interface Rpc { @@ -18,3 +217,14 @@ interface Rpc { data: Uint8Array ): Promise; } + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; diff --git a/x/cosmostest/client/cli/tx.go b/x/cosmostest/client/cli/tx.go index 4f67119..d3aebc4 100644 --- a/x/cosmostest/client/cli/tx.go +++ b/x/cosmostest/client/cli/tx.go @@ -30,6 +30,7 @@ func GetTxCmd() *cobra.Command { RunE: client.ValidateCmd, } + cmd.AddCommand(CmdNewAuction()) // this line is used by starport scaffolding # 1 return cmd diff --git a/x/cosmostest/client/cli/tx_new_auction.go b/x/cosmostest/client/cli/tx_new_auction.go new file mode 100644 index 0000000..4aca8bb --- /dev/null +++ b/x/cosmostest/client/cli/tx_new_auction.go @@ -0,0 +1,46 @@ +package cli + +import ( + "strconv" + + "cosmos-test/x/cosmostest/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/spf13/cobra" +) + +var _ = strconv.Itoa(0) + +func CmdNewAuction() *cobra.Command { + cmd := &cobra.Command{ + Use: "new-auction [owner] [name] [description]", + Short: "Broadcast message newAuction", + Args: cobra.ExactArgs(3), + RunE: func(cmd *cobra.Command, args []string) (err error) { + argOwner := args[0] + argName := args[1] + argDescription := args[2] + + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgNewAuction( + clientCtx.GetFromAddress().String(), + argOwner, + argName, + argDescription, + ) + if err := msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} diff --git a/x/cosmostest/handler.go b/x/cosmostest/handler.go index d8ad5e7..cdd9214 100644 --- a/x/cosmostest/handler.go +++ b/x/cosmostest/handler.go @@ -11,13 +11,16 @@ import ( // NewHandler ... func NewHandler(k keeper.Keeper) sdk.Handler { - // this line is used by starport scaffolding # handler/msgServer + msgServer := keeper.NewMsgServerImpl(k) return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) { ctx = ctx.WithEventManager(sdk.NewEventManager()) switch msg := msg.(type) { - // this line is used by starport scaffolding # 1 + case *types.MsgNewAuction: + res, err := msgServer.NewAuction(sdk.WrapSDKContext(ctx), msg) + return sdk.WrapServiceResult(ctx, res, err) + // this line is used by starport scaffolding # 1 default: errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg) return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg) diff --git a/x/cosmostest/keeper/msg_server_new_auction.go b/x/cosmostest/keeper/msg_server_new_auction.go new file mode 100644 index 0000000..1e0bd52 --- /dev/null +++ b/x/cosmostest/keeper/msg_server_new_auction.go @@ -0,0 +1,17 @@ +package keeper + +import ( + "context" + + "cosmos-test/x/cosmostest/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (k msgServer) NewAuction(goCtx context.Context, msg *types.MsgNewAuction) (*types.MsgNewAuctionResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + // TODO: Handling the message + _ = ctx + + return &types.MsgNewAuctionResponse{}, nil +} diff --git a/x/cosmostest/module_simulation.go b/x/cosmostest/module_simulation.go index 27c68f7..0d76cef 100644 --- a/x/cosmostest/module_simulation.go +++ b/x/cosmostest/module_simulation.go @@ -24,7 +24,11 @@ var ( ) const ( -// this line is used by starport scaffolding # simapp/module/const + opWeightMsgNewAuction = "op_weight_msg_new_auction" + // TODO: Determine the simulation weight value + defaultWeightMsgNewAuction int = 100 + + // this line is used by starport scaffolding # simapp/module/const ) // GenerateGenesisState creates a randomized GenState of the module @@ -58,6 +62,17 @@ func (am AppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) {} func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation { operations := make([]simtypes.WeightedOperation, 0) + var weightMsgNewAuction int + simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgNewAuction, &weightMsgNewAuction, nil, + func(_ *rand.Rand) { + weightMsgNewAuction = defaultWeightMsgNewAuction + }, + ) + operations = append(operations, simulation.NewWeightedOperation( + weightMsgNewAuction, + cosmostestsimulation.SimulateMsgNewAuction(am.accountKeeper, am.bankKeeper, am.keeper), + )) + // this line is used by starport scaffolding # simapp/module/operation return operations diff --git a/x/cosmostest/simulation/new_auction.go b/x/cosmostest/simulation/new_auction.go new file mode 100644 index 0000000..d62ff39 --- /dev/null +++ b/x/cosmostest/simulation/new_auction.go @@ -0,0 +1,29 @@ +package simulation + +import ( + "math/rand" + + "cosmos-test/x/cosmostest/keeper" + "cosmos-test/x/cosmostest/types" + "github.com/cosmos/cosmos-sdk/baseapp" + sdk "github.com/cosmos/cosmos-sdk/types" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" +) + +func SimulateMsgNewAuction( + ak types.AccountKeeper, + bk types.BankKeeper, + k keeper.Keeper, +) simtypes.Operation { + return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + simAccount, _ := simtypes.RandomAcc(r, accs) + msg := &types.MsgNewAuction{ + Creator: simAccount.Address.String(), + } + + // TODO: Handling the NewAuction simulation + + return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "NewAuction simulation not implemented"), nil, nil + } +} diff --git a/x/cosmostest/types/codec.go b/x/cosmostest/types/codec.go index 844157a..b6a9138 100644 --- a/x/cosmostest/types/codec.go +++ b/x/cosmostest/types/codec.go @@ -3,15 +3,19 @@ package types import ( "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - // this line is used by starport scaffolding # 1 + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/msgservice" ) func RegisterCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgNewAuction{}, "cosmostest/NewAuction", nil) // this line is used by starport scaffolding # 2 } func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgNewAuction{}, + ) // this line is used by starport scaffolding # 3 msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) diff --git a/x/cosmostest/types/message_new_auction.go b/x/cosmostest/types/message_new_auction.go new file mode 100644 index 0000000..991ee2e --- /dev/null +++ b/x/cosmostest/types/message_new_auction.go @@ -0,0 +1,48 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +const TypeMsgNewAuction = "new_auction" + +var _ sdk.Msg = &MsgNewAuction{} + +func NewMsgNewAuction(creator string, owner string, name string, description string) *MsgNewAuction { + return &MsgNewAuction{ + Creator: creator, + Owner: owner, + Name: name, + Description: description, + } +} + +func (msg *MsgNewAuction) Route() string { + return RouterKey +} + +func (msg *MsgNewAuction) Type() string { + return TypeMsgNewAuction +} + +func (msg *MsgNewAuction) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgNewAuction) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgNewAuction) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + return nil +} diff --git a/x/cosmostest/types/message_new_auction_test.go b/x/cosmostest/types/message_new_auction_test.go new file mode 100644 index 0000000..d624ef2 --- /dev/null +++ b/x/cosmostest/types/message_new_auction_test.go @@ -0,0 +1,40 @@ +package types + +import ( + "testing" + + "cosmos-test/testutil/sample" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/stretchr/testify/require" +) + +func TestMsgNewAuction_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgNewAuction + err error + }{ + { + name: "invalid address", + msg: MsgNewAuction{ + Creator: "invalid_address", + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "valid address", + msg: MsgNewAuction{ + Creator: sample.AccAddress(), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} diff --git a/x/cosmostest/types/tx.pb.go b/x/cosmostest/types/tx.pb.go index c105561..6cd5c70 100644 --- a/x/cosmostest/types/tx.pb.go +++ b/x/cosmostest/types/tx.pb.go @@ -9,7 +9,11 @@ import ( grpc1 "github.com/gogo/protobuf/grpc" proto "github.com/gogo/protobuf/proto" grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" math "math" + math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. @@ -23,17 +27,142 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +type MsgNewAuction struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` +} + +func (m *MsgNewAuction) Reset() { *m = MsgNewAuction{} } +func (m *MsgNewAuction) String() string { return proto.CompactTextString(m) } +func (*MsgNewAuction) ProtoMessage() {} +func (*MsgNewAuction) Descriptor() ([]byte, []int) { + return fileDescriptor_2fcd5aa4ac15d93c, []int{0} +} +func (m *MsgNewAuction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgNewAuction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgNewAuction.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 *MsgNewAuction) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgNewAuction.Merge(m, src) +} +func (m *MsgNewAuction) XXX_Size() int { + return m.Size() +} +func (m *MsgNewAuction) XXX_DiscardUnknown() { + xxx_messageInfo_MsgNewAuction.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgNewAuction proto.InternalMessageInfo + +func (m *MsgNewAuction) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *MsgNewAuction) GetOwner() string { + if m != nil { + return m.Owner + } + return "" +} + +func (m *MsgNewAuction) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *MsgNewAuction) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +type MsgNewAuctionResponse struct { + AuctionId string `protobuf:"bytes,1,opt,name=auctionId,proto3" json:"auctionId,omitempty"` +} + +func (m *MsgNewAuctionResponse) Reset() { *m = MsgNewAuctionResponse{} } +func (m *MsgNewAuctionResponse) String() string { return proto.CompactTextString(m) } +func (*MsgNewAuctionResponse) ProtoMessage() {} +func (*MsgNewAuctionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_2fcd5aa4ac15d93c, []int{1} +} +func (m *MsgNewAuctionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgNewAuctionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgNewAuctionResponse.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 *MsgNewAuctionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgNewAuctionResponse.Merge(m, src) +} +func (m *MsgNewAuctionResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgNewAuctionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgNewAuctionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgNewAuctionResponse proto.InternalMessageInfo + +func (m *MsgNewAuctionResponse) GetAuctionId() string { + if m != nil { + return m.AuctionId + } + return "" +} + +func init() { + proto.RegisterType((*MsgNewAuction)(nil), "cosmostest.cosmostest.MsgNewAuction") + proto.RegisterType((*MsgNewAuctionResponse)(nil), "cosmostest.cosmostest.MsgNewAuctionResponse") +} + func init() { proto.RegisterFile("cosmostest/tx.proto", fileDescriptor_2fcd5aa4ac15d93c) } var fileDescriptor_2fcd5aa4ac15d93c = []byte{ - // 107 bytes of a gzipped FileDescriptorProto + // 239 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4e, 0xce, 0x2f, 0xce, 0xcd, 0x2f, 0x2e, 0x49, 0x2d, 0x2e, 0xd1, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, - 0x12, 0x45, 0x08, 0xea, 0x21, 0x98, 0x46, 0xac, 0x5c, 0xcc, 0xbe, 0xc5, 0xe9, 0x4e, 0x16, 0x27, - 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, - 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0x25, 0x07, 0x51, 0xac, 0x0b, 0x36, 0xad, - 0x42, 0x1f, 0xd9, 0xe8, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xf1, 0xc6, 0x80, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x4b, 0xa2, 0x40, 0x3a, 0x75, 0x00, 0x00, 0x00, + 0x12, 0x45, 0x08, 0xea, 0x21, 0x98, 0x4a, 0xa5, 0x5c, 0xbc, 0xbe, 0xc5, 0xe9, 0x7e, 0xa9, 0xe5, + 0x8e, 0xa5, 0xc9, 0x25, 0x99, 0xf9, 0x79, 0x42, 0x12, 0x5c, 0xec, 0xc9, 0x45, 0xa9, 0x89, 0x25, + 0xf9, 0x45, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x7e, + 0x79, 0x5e, 0x6a, 0x91, 0x04, 0x13, 0x58, 0x1c, 0xc2, 0x11, 0x12, 0xe2, 0x62, 0xc9, 0x4b, 0xcc, + 0x4d, 0x95, 0x60, 0x06, 0x0b, 0x82, 0xd9, 0x42, 0x0a, 0x5c, 0xdc, 0x29, 0xa9, 0xc5, 0xc9, 0x45, + 0x99, 0x05, 0x20, 0x23, 0x25, 0x58, 0xc0, 0x52, 0xc8, 0x42, 0x4a, 0xa6, 0x5c, 0xa2, 0x28, 0xd6, + 0x06, 0xa5, 0x16, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0xc9, 0x70, 0x71, 0x26, 0x42, 0x84, 0x3c, + 0x53, 0xa0, 0x0e, 0x40, 0x08, 0x18, 0xa5, 0x73, 0x31, 0xfb, 0x16, 0xa7, 0x0b, 0x25, 0x70, 0x71, + 0x21, 0xb9, 0x58, 0x45, 0x0f, 0xab, 0xd7, 0xf4, 0x50, 0x2c, 0x90, 0xd2, 0x21, 0x46, 0x15, 0xcc, + 0x19, 0x4e, 0x16, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, + 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0x25, 0x07, 0xd1, + 0xab, 0x0b, 0x0e, 0xdd, 0x0a, 0x7d, 0xe4, 0xa0, 0xae, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x07, + 0xb7, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xb3, 0x83, 0x38, 0xc2, 0x85, 0x01, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -48,6 +177,7 @@ const _ = grpc.SupportPackageIsVersion4 // // 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 { + NewAuction(ctx context.Context, in *MsgNewAuction, opts ...grpc.CallOption) (*MsgNewAuctionResponse, error) } type msgClient struct { @@ -58,22 +188,540 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient { return &msgClient{cc} } +func (c *msgClient) NewAuction(ctx context.Context, in *MsgNewAuction, opts ...grpc.CallOption) (*MsgNewAuctionResponse, error) { + out := new(MsgNewAuctionResponse) + err := c.cc.Invoke(ctx, "/cosmostest.cosmostest.Msg/NewAuction", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { + NewAuction(context.Context, *MsgNewAuction) (*MsgNewAuctionResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. type UnimplementedMsgServer struct { } +func (*UnimplementedMsgServer) NewAuction(ctx context.Context, req *MsgNewAuction) (*MsgNewAuctionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method NewAuction not implemented") +} + func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) } +func _Msg_NewAuction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgNewAuction) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).NewAuction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmostest.cosmostest.Msg/NewAuction", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).NewAuction(ctx, req.(*MsgNewAuction)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "cosmostest.cosmostest.Msg", HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{}, - Streams: []grpc.StreamDesc{}, - Metadata: "cosmostest/tx.proto", + Methods: []grpc.MethodDesc{ + { + MethodName: "NewAuction", + Handler: _Msg_NewAuction_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmostest/tx.proto", } + +func (m *MsgNewAuction) 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 *MsgNewAuction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgNewAuction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintTx(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x22 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintTx(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + } + 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] = 0x12 + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgNewAuctionResponse) 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 *MsgNewAuctionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgNewAuctionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AuctionId) > 0 { + i -= len(m.AuctionId) + copy(dAtA[i:], m.AuctionId) + i = encodeVarintTx(dAtA, i, uint64(len(m.AuctionId))) + 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 *MsgNewAuction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgNewAuctionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.AuctionId) + 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 *MsgNewAuction) 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: MsgNewAuction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgNewAuction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = 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 *MsgNewAuctionResponse) 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: MsgNewAuctionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgNewAuctionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", 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.AuctionId = 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 skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +)