scaffold newBid tx

x/cosmostest/client/cli/tx.go

@@ -31,6 +31,7 @@ func GetTxCmd() *cobra.Command {
 	}
 
 	cmd.AddCommand(CmdNewAuction())
+	cmd.AddCommand(CmdNewBid())
 	// this line is used by starport scaffolding # 1
 
 	return cmd

x/cosmostest/client/cli/tx_new_bid.go

@@ -0,0 +1,44 @@
+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 CmdNewBid() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "new-bid [auction-index] [amount]",
+		Short: "Broadcast message newBid",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			argAuctionIndex := args[0]
+			argAmount := args[1]
+
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			msg := types.NewMsgNewBid(
+				clientCtx.GetFromAddress().String(),
+				argAuctionIndex,
+				argAmount,
+			)
+			if err := msg.ValidateBasic(); err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

x/cosmostest/handler.go

@@ -20,6 +20,9 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgNewAuction:
 			res, err := msgServer.NewAuction(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgNewBid:
+			res, err := msgServer.NewBid(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)

x/cosmostest/keeper/msg_server_new_bid.go

@@ -0,0 +1,17 @@
+package keeper
+
+import (
+	"context"
+
+	"cosmos-test/x/cosmostest/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (k msgServer) NewBid(goCtx context.Context, msg *types.MsgNewBid) (*types.MsgNewBidResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// TODO: Handling the message
+	_ = ctx
+
+	return &types.MsgNewBidResponse{}, nil
+}

x/cosmostest/module_simulation.go

@@ -28,6 +28,10 @@ const (
 	// TODO: Determine the simulation weight value
 	defaultWeightMsgNewAuction int = 100
 
+	opWeightMsgNewBid = "op_weight_msg_new_bid"
+	// TODO: Determine the simulation weight value
+	defaultWeightMsgNewBid int = 100
+
 	// this line is used by starport scaffolding # simapp/module/const
 )
 
@@ -73,6 +77,17 @@ func (am AppModule) WeightedOperations(simState module.SimulationState) []simtyp
 		cosmostestsimulation.SimulateMsgNewAuction(am.accountKeeper, am.bankKeeper, am.keeper),
 	))
 
+	var weightMsgNewBid int
+	simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgNewBid, &weightMsgNewBid, nil,
+		func(_ *rand.Rand) {
+			weightMsgNewBid = defaultWeightMsgNewBid
+		},
+	)
+	operations = append(operations, simulation.NewWeightedOperation(
+		weightMsgNewBid,
+		cosmostestsimulation.SimulateMsgNewBid(am.accountKeeper, am.bankKeeper, am.keeper),
+	))
+
 	// this line is used by starport scaffolding # simapp/module/operation
 
 	return operations

x/cosmostest/simulation/new_bid.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 SimulateMsgNewBid(
+	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.MsgNewBid{
+			Creator: simAccount.Address.String(),
+		}
+
+		// TODO: Handling the NewBid simulation
+
+		return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "NewBid simulation not implemented"), nil, nil
+	}
+}

x/cosmostest/types/codec.go

@@ -9,6 +9,7 @@ import (
 
 func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgNewAuction{}, "cosmostest/NewAuction", nil)
+	cdc.RegisterConcrete(&MsgNewBid{}, "cosmostest/NewBid", nil)
 	// this line is used by starport scaffolding # 2
 }
 
@@ -16,6 +17,9 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 	registry.RegisterImplementations((*sdk.Msg)(nil),
 		&MsgNewAuction{},
 	)
+	registry.RegisterImplementations((*sdk.Msg)(nil),
+		&MsgNewBid{},
+	)
 	// this line is used by starport scaffolding # 3
 
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)

x/cosmostest/types/message_new_bid.go

@@ -0,0 +1,47 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+const TypeMsgNewBid = "new_bid"
+
+var _ sdk.Msg = &MsgNewBid{}
+
+func NewMsgNewBid(creator string, auctionIndex string, amount string) *MsgNewBid {
+	return &MsgNewBid{
+		Creator:      creator,
+		AuctionIndex: auctionIndex,
+		Amount:       amount,
+	}
+}
+
+func (msg *MsgNewBid) Route() string {
+	return RouterKey
+}
+
+func (msg *MsgNewBid) Type() string {
+	return TypeMsgNewBid
+}
+
+func (msg *MsgNewBid) GetSigners() []sdk.AccAddress {
+	creator, err := sdk.AccAddressFromBech32(msg.Creator)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{creator}
+}
+
+func (msg *MsgNewBid) GetSignBytes() []byte {
+	bz := ModuleCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+func (msg *MsgNewBid) ValidateBasic() error {
+	_, err := sdk.AccAddressFromBech32(msg.Creator)
+	if err != nil {
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err)
+	}
+	return nil
+}

x/cosmostest/types/message_new_bid_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 TestMsgNewBid_ValidateBasic(t *testing.T) {
+	tests := []struct {
+		name string
+		msg  MsgNewBid
+		err  error
+	}{
+		{
+			name: "invalid address",
+			msg: MsgNewBid{
+				Creator: "invalid_address",
+			},
+			err: sdkerrors.ErrInvalidAddress,
+		}, {
+			name: "valid address",
+			msg: MsgNewBid{
+				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)
+		})
+	}
+}

x/cosmostest/types/tx.pb.go

@@ -139,15 +139,113 @@ func (m *MsgNewAuctionResponse) GetAuctionId() string {
 	return ""
 }
 
+type MsgNewBid struct {
+	Creator      string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+	AuctionIndex string `protobuf:"bytes,2,opt,name=auctionIndex,proto3" json:"auctionIndex,omitempty"`
+	Amount       string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (m *MsgNewBid) Reset()         { *m = MsgNewBid{} }
+func (m *MsgNewBid) String() string { return proto.CompactTextString(m) }
+func (*MsgNewBid) ProtoMessage()    {}
+func (*MsgNewBid) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2fcd5aa4ac15d93c, []int{2}
+}
+func (m *MsgNewBid) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgNewBid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgNewBid.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 *MsgNewBid) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgNewBid.Merge(m, src)
+}
+func (m *MsgNewBid) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgNewBid) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgNewBid.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgNewBid proto.InternalMessageInfo
+
+func (m *MsgNewBid) GetCreator() string {
+	if m != nil {
+		return m.Creator
+	}
+	return ""
+}
+
+func (m *MsgNewBid) GetAuctionIndex() string {
+	if m != nil {
+		return m.AuctionIndex
+	}
+	return ""
+}
+
+func (m *MsgNewBid) GetAmount() string {
+	if m != nil {
+		return m.Amount
+	}
+	return ""
+}
+
+type MsgNewBidResponse struct {
+}
+
+func (m *MsgNewBidResponse) Reset()         { *m = MsgNewBidResponse{} }
+func (m *MsgNewBidResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgNewBidResponse) ProtoMessage()    {}
+func (*MsgNewBidResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2fcd5aa4ac15d93c, []int{3}
+}
+func (m *MsgNewBidResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgNewBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgNewBidResponse.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 *MsgNewBidResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgNewBidResponse.Merge(m, src)
+}
+func (m *MsgNewBidResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgNewBidResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgNewBidResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgNewBidResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*MsgNewAuction)(nil), "cosmostest.cosmostest.MsgNewAuction")
 	proto.RegisterType((*MsgNewAuctionResponse)(nil), "cosmostest.cosmostest.MsgNewAuctionResponse")
+	proto.RegisterType((*MsgNewBid)(nil), "cosmostest.cosmostest.MsgNewBid")
+	proto.RegisterType((*MsgNewBidResponse)(nil), "cosmostest.cosmostest.MsgNewBidResponse")
 }
 
 func init() { proto.RegisterFile("cosmostest/tx.proto", fileDescriptor_2fcd5aa4ac15d93c) }
 
 var fileDescriptor_2fcd5aa4ac15d93c = []byte{
-	// 239 bytes of a gzipped FileDescriptorProto
+	// 306 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, 0x4a, 0xa5, 0x5c, 0xbc, 0xbe, 0xc5, 0xe9, 0x7e, 0xa9, 0xe5,
@@ -157,12 +255,17 @@ var fileDescriptor_2fcd5aa4ac15d93c = []byte{
 	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,
+	0x53, 0xa0, 0x0e, 0x40, 0x08, 0x28, 0x25, 0x72, 0x71, 0x42, 0xb4, 0x39, 0x65, 0xa6, 0xe0, 0x71,
+	0xa9, 0x12, 0x17, 0x0f, 0x4c, 0x4f, 0x5e, 0x4a, 0x6a, 0x05, 0xd4, 0xc1, 0x28, 0x62, 0x42, 0x62,
+	0x5c, 0x6c, 0x89, 0xb9, 0xf9, 0xa5, 0x79, 0x25, 0x50, 0x97, 0x43, 0x79, 0x4a, 0xc2, 0x5c, 0x82,
+	0x70, 0x2b, 0x60, 0xae, 0x32, 0xda, 0xcb, 0xc8, 0xc5, 0xec, 0x5b, 0x9c, 0x2e, 0x94, 0xc0, 0xc5,
+	0x85, 0x14, 0x54, 0x2a, 0x7a, 0x58, 0xc3, 0x54, 0x0f, 0xc5, 0x67, 0x52, 0x3a, 0xc4, 0xa8, 0x82,
+	0xfb, 0x3f, 0x84, 0x8b, 0x0d, 0xea, 0x3d, 0x05, 0xbc, 0xfa, 0x9c, 0x32, 0x53, 0xa4, 0x34, 0x08,
+	0xa9, 0x80, 0x99, 0xea, 0x64, 0x71, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e,
+	0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51,
+	0x72, 0x10, 0x7d, 0xba, 0xe0, 0xc4, 0x52, 0xa1, 0x8f, 0x9c, 0x72, 0x2a, 0x0b, 0x52, 0x8b, 0x93,
+	0xd8, 0xc0, 0xa9, 0xc7, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x5f, 0xf4, 0xdf, 0xab, 0x54, 0x02,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -178,6 +281,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)
+	NewBid(ctx context.Context, in *MsgNewBid, opts ...grpc.CallOption) (*MsgNewBidResponse, error)
 }
 
 type msgClient struct {
@@ -197,9 +301,19 @@ func (c *msgClient) NewAuction(ctx context.Context, in *MsgNewAuction, opts ...g
 	return out, nil
 }
 
+func (c *msgClient) NewBid(ctx context.Context, in *MsgNewBid, opts ...grpc.CallOption) (*MsgNewBidResponse, error) {
+	out := new(MsgNewBidResponse)
+	err := c.cc.Invoke(ctx, "/cosmostest.cosmostest.Msg/NewBid", 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)
+	NewBid(context.Context, *MsgNewBid) (*MsgNewBidResponse, error)
 }
 
 // UnimplementedMsgServer can be embedded to have forward compatible implementations.
@@ -209,6 +323,9 @@ type UnimplementedMsgServer struct {
 func (*UnimplementedMsgServer) NewAuction(ctx context.Context, req *MsgNewAuction) (*MsgNewAuctionResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method NewAuction not implemented")
 }
+func (*UnimplementedMsgServer) NewBid(ctx context.Context, req *MsgNewBid) (*MsgNewBidResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NewBid not implemented")
+}
 
 func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
 	s.RegisterService(&_Msg_serviceDesc, srv)
@@ -232,6 +349,24 @@ func _Msg_NewAuction_Handler(srv interface{}, ctx context.Context, dec func(inte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_NewBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgNewBid)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).NewBid(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmostest.cosmostest.Msg/NewBid",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).NewBid(ctx, req.(*MsgNewBid))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Msg_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "cosmostest.cosmostest.Msg",
 	HandlerType: (*MsgServer)(nil),
@@ -240,6 +375,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "NewAuction",
 			Handler:    _Msg_NewAuction_Handler,
 		},
+		{
+			MethodName: "NewBid",
+			Handler:    _Msg_NewBid_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "cosmostest/tx.proto",
@@ -326,6 +465,73 @@ func (m *MsgNewAuctionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgNewBid) 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 *MsgNewBid) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgNewBid) 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] = 0x1a
+	}
+	if len(m.AuctionIndex) > 0 {
+		i -= len(m.AuctionIndex)
+		copy(dAtA[i:], m.AuctionIndex)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.AuctionIndex)))
+		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 *MsgNewBidResponse) 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 *MsgNewBidResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgNewBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTx(v)
 	base := offset
@@ -375,6 +581,36 @@ func (m *MsgNewAuctionResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgNewBid) 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.AuctionIndex)
+	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 *MsgNewBidResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func sovTx(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -641,6 +877,202 @@ func (m *MsgNewAuctionResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgNewBid) 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: MsgNewBid: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgNewBid: 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 AuctionIndex", 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.AuctionIndex = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			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:])
+			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 *MsgNewBidResponse) 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: MsgNewBidResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgNewBidResponse: 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 skipTx(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0