From 1ad5bbc58bf29a90a27f742418e56091e3a7ae9e Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Tue, 26 Mar 2024 14:20:34 +0100
Subject: [PATCH 1/9] update auction proto

---
 proto/umee/auction/v1/auction.proto |  3 --
 proto/umee/auction/v1/tx.proto      |  3 +-
 x/auction/auction.pb.go             | 48 +++--------------
 x/auction/tx.pb.go                  | 84 ++++++++++++++---------------
 4 files changed, 51 insertions(+), 87 deletions(-)

diff --git a/proto/umee/auction/v1/auction.proto b/proto/umee/auction/v1/auction.proto
index 95b1d858bc..5cab299d13 100644
--- a/proto/umee/auction/v1/auction.proto
+++ b/proto/umee/auction/v1/auction.proto
@@ -10,7 +10,4 @@ option (gogoproto.goproto_getters_all) = false;
 message RewardsParams {
   // bid_duration is duration of the bid phase in seconds.
   int64 bid_duration = 1;
-  // Duration (in seconds) at the end of each auction, when we start collecting revenues for
-  // the next auction.
-  int64 revenu_collection_shift = 2;
 }
diff --git a/proto/umee/auction/v1/tx.proto b/proto/umee/auction/v1/tx.proto
index e65edfb59d..48054370f4 100644
--- a/proto/umee/auction/v1/tx.proto
+++ b/proto/umee/auction/v1/tx.proto
@@ -1,7 +1,6 @@
 syntax = "proto3";
 package umee.auction.v1;
 
-import "cosmos/base/v1beta1/coin.proto";
 import "cosmos_proto/cosmos.proto";
 import "cosmos/msg/v1/msg.proto";
 import "gogoproto/gogo.proto";
@@ -44,7 +43,7 @@ message MsgRewardsBid {
   // the current auction ID being bid on. Fails if the ID is not an ID of the current auction.
   uint32 id = 2;
   // amount of the bid in the base tokens
-  cosmos.base.v1beta1.Coin bid_amount = 3 [(gogoproto.nullable) = false];
+  string amount = 3 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.nullable) = false];
 }
 
 // MsgRewardsBidResponse response type for Msg/RewardsBid
diff --git a/x/auction/auction.pb.go b/x/auction/auction.pb.go
index fd51a40ee5..edb61ea20e 100644
--- a/x/auction/auction.pb.go
+++ b/x/auction/auction.pb.go
@@ -27,9 +27,6 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 type RewardsParams struct {
 	// bid_duration is duration of the bid phase in seconds.
 	BidDuration int64 `protobuf:"varint,1,opt,name=bid_duration,json=bidDuration,proto3" json:"bid_duration,omitempty"`
-	// Duration (in seconds) at the end of each auction, when we start collecting revenues for
-	// the next auction.
-	RevenuCollectionShift int64 `protobuf:"varint,2,opt,name=revenu_collection_shift,json=revenuCollectionShift,proto3" json:"revenu_collection_shift,omitempty"`
 }
 
 func (m *RewardsParams) Reset()         { *m = RewardsParams{} }
@@ -72,21 +69,19 @@ func init() {
 func init() { proto.RegisterFile("umee/auction/v1/auction.proto", fileDescriptor_7a7eec280427e7e3) }
 
 var fileDescriptor_7a7eec280427e7e3 = []byte{
-	// 221 bytes of a gzipped FileDescriptorProto
+	// 184 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2d, 0xcd, 0x4d, 0x4d,
 	0xd5, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0x84, 0x31, 0xf5, 0x0a, 0x8a,
 	0xf2, 0x4b, 0xf2, 0x85, 0xf8, 0x41, 0xd2, 0x7a, 0x30, 0xb1, 0x32, 0x43, 0x29, 0x91, 0xf4, 0xfc,
-	0xf4, 0x7c, 0xb0, 0x9c, 0x3e, 0x88, 0x05, 0x51, 0xa6, 0x94, 0xc5, 0xc5, 0x1b, 0x94, 0x5a, 0x9e,
+	0xf4, 0x7c, 0xb0, 0x9c, 0x3e, 0x88, 0x05, 0x51, 0xa6, 0x64, 0xc4, 0xc5, 0x1b, 0x94, 0x5a, 0x9e,
 	0x58, 0x94, 0x52, 0x1c, 0x90, 0x58, 0x94, 0x98, 0x5b, 0x2c, 0xa4, 0xc8, 0xc5, 0x93, 0x94, 0x99,
 	0x12, 0x9f, 0x52, 0x5a, 0x94, 0x08, 0xd2, 0x29, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x1c, 0xc4, 0x9d,
-	0x94, 0x99, 0xe2, 0x02, 0x15, 0x12, 0x32, 0xe3, 0x12, 0x2f, 0x4a, 0x2d, 0x4b, 0xcd, 0x2b, 0x8d,
-	0x4f, 0xce, 0xcf, 0xc9, 0x49, 0x05, 0xdb, 0x10, 0x5f, 0x9c, 0x91, 0x99, 0x56, 0x22, 0xc1, 0x04,
-	0x56, 0x2d, 0x0a, 0x91, 0x76, 0x86, 0xcb, 0x06, 0x83, 0x24, 0x9d, 0xdc, 0x4f, 0x3c, 0x94, 0x63,
-	0x38, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96,
-	0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xcd, 0xf4, 0xcc, 0x92, 0x8c,
-	0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x90, 0xdb, 0x75, 0xf3, 0x52, 0x4b, 0xca, 0xf3, 0x8b,
-	0xb2, 0xc1, 0x1c, 0xfd, 0x32, 0x33, 0xfd, 0x0a, 0x98, 0x0f, 0x93, 0xd8, 0xc0, 0x6e, 0x37, 0x06,
-	0x04, 0x00, 0x00, 0xff, 0xff, 0x54, 0x46, 0x9a, 0x8f, 0x03, 0x01, 0x00, 0x00,
+	0x94, 0x99, 0xe2, 0x02, 0x15, 0x72, 0x72, 0x3f, 0xf1, 0x50, 0x8e, 0xe1, 0xc4, 0x23, 0x39, 0xc6,
+	0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39,
+	0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0x34, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3,
+	0x73, 0xf5, 0x41, 0x6e, 0xd0, 0xcd, 0x4b, 0x2d, 0x29, 0xcf, 0x2f, 0xca, 0x06, 0x73, 0xf4, 0xcb,
+	0xcc, 0xf4, 0x2b, 0x60, 0x2e, 0x4d, 0x62, 0x03, 0xbb, 0xc1, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
+	0xa4, 0x42, 0x37, 0xb0, 0xcb, 0x00, 0x00, 0x00,
 }
 
 func (m *RewardsParams) Marshal() (dAtA []byte, err error) {
@@ -109,11 +104,6 @@ func (m *RewardsParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.RevenuCollectionShift != 0 {
-		i = encodeVarintAuction(dAtA, i, uint64(m.RevenuCollectionShift))
-		i--
-		dAtA[i] = 0x10
-	}
 	if m.BidDuration != 0 {
 		i = encodeVarintAuction(dAtA, i, uint64(m.BidDuration))
 		i--
@@ -142,9 +132,6 @@ func (m *RewardsParams) Size() (n int) {
 	if m.BidDuration != 0 {
 		n += 1 + sovAuction(uint64(m.BidDuration))
 	}
-	if m.RevenuCollectionShift != 0 {
-		n += 1 + sovAuction(uint64(m.RevenuCollectionShift))
-	}
 	return n
 }
 
@@ -202,25 +189,6 @@ func (m *RewardsParams) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RevenuCollectionShift", wireType)
-			}
-			m.RevenuCollectionShift = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowAuction
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.RevenuCollectionShift |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipAuction(dAtA[iNdEx:])
diff --git a/x/auction/tx.pb.go b/x/auction/tx.pb.go
index 61e87ac737..0984d36205 100644
--- a/x/auction/tx.pb.go
+++ b/x/auction/tx.pb.go
@@ -5,9 +5,9 @@ package auction
 
 import (
 	context "context"
+	cosmossdk_io_math "cosmossdk.io/math"
 	fmt "fmt"
 	_ "github.com/cosmos/cosmos-proto"
-	types "github.com/cosmos/cosmos-sdk/types"
 	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
 	_ "github.com/cosmos/gogoproto/gogoproto"
 	grpc1 "github.com/cosmos/gogoproto/grpc"
@@ -122,7 +122,7 @@ type MsgRewardsBid struct {
 	// the current auction ID being bid on. Fails if the ID is not an ID of the current auction.
 	Id uint32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
 	// amount of the bid in the base tokens
-	BidAmount types.Coin `protobuf:"bytes,3,opt,name=bid_amount,json=bidAmount,proto3" json:"bid_amount"`
+	Amount cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
 }
 
 func (m *MsgRewardsBid) Reset()         { *m = MsgRewardsBid{} }
@@ -212,36 +212,35 @@ func init() {
 func init() { proto.RegisterFile("umee/auction/v1/tx.proto", fileDescriptor_44a5dea2889d94ea) }
 
 var fileDescriptor_44a5dea2889d94ea = []byte{
-	// 461 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x6a, 0x14, 0x31,
-	0x18, 0xc7, 0x27, 0x5b, 0x59, 0xd8, 0x94, 0x56, 0x18, 0x6b, 0x3b, 0x5d, 0x30, 0x2e, 0x7b, 0xd0,
-	0x2a, 0x34, 0x61, 0x2b, 0xf4, 0x50, 0x44, 0xe8, 0x7a, 0xf0, 0x20, 0x0b, 0x32, 0xf5, 0xe4, 0xa5,
-	0xcc, 0x6c, 0x42, 0x1a, 0x64, 0xe6, 0x5b, 0x92, 0xcc, 0xb4, 0x5e, 0xc5, 0x07, 0xf0, 0x09, 0x7c,
-	0x06, 0x0f, 0x3e, 0xc4, 0x1e, 0x3c, 0x14, 0x4f, 0x9e, 0x44, 0x77, 0x0f, 0xbe, 0x86, 0x4c, 0x26,
-	0xc3, 0xda, 0x3a, 0x48, 0x6f, 0xf3, 0xcd, 0x3f, 0xff, 0xff, 0xf7, 0xfb, 0xbe, 0x04, 0x47, 0x45,
-	0x26, 0x04, 0x4b, 0x8a, 0xa9, 0x55, 0x90, 0xb3, 0x72, 0xc4, 0xec, 0x05, 0x9d, 0x69, 0xb0, 0x10,
-	0xde, 0xae, 0x14, 0xea, 0x15, 0x5a, 0x8e, 0xfa, 0x64, 0x0a, 0x26, 0x03, 0xc3, 0xd2, 0xc4, 0x08,
-	0x56, 0x8e, 0x52, 0x61, 0x93, 0x11, 0x9b, 0x82, 0xca, 0x6b, 0x43, 0x7f, 0xb7, 0xd6, 0x4f, 0x5d,
-	0xc5, 0xea, 0xc2, 0x4b, 0x3b, 0xde, 0x9a, 0x19, 0x59, 0xf5, 0xc8, 0x8c, 0xf4, 0xc2, 0x96, 0x04,
-	0x09, 0xb5, 0xa1, 0xfa, 0xf2, 0x7f, 0xef, 0x5d, 0x87, 0x6a, 0x28, 0x9c, 0x3c, 0xfc, 0x84, 0xf0,
-	0xf6, 0xc4, 0xc8, 0x17, 0x50, 0x9e, 0x08, 0x1b, 0x8b, 0xf3, 0x44, 0x73, 0xf3, 0x2a, 0xd1, 0x49,
-	0x66, 0xc2, 0x43, 0xdc, 0x4b, 0x0a, 0x7b, 0x06, 0x5a, 0xd9, 0x77, 0x11, 0x1a, 0xa0, 0xbd, 0xde,
-	0x38, 0xfa, 0xf6, 0x65, 0x7f, 0xcb, 0xd3, 0x1c, 0x73, 0xae, 0x85, 0x31, 0x27, 0x56, 0xab, 0x5c,
-	0xc6, 0xab, 0xa3, 0xe1, 0x53, 0xdc, 0x9d, 0xb9, 0x84, 0xa8, 0x33, 0x40, 0x7b, 0xeb, 0x07, 0x84,
-	0x5e, 0x9b, 0x9e, 0x5e, 0xe9, 0x33, 0xbe, 0x35, 0xff, 0x71, 0x3f, 0x88, 0xbd, 0xe7, 0x68, 0xf3,
-	0xfd, 0xef, 0xcf, 0x8f, 0x57, 0x69, 0xc3, 0x01, 0x26, 0xed, 0x7c, 0xb1, 0x30, 0x33, 0xc8, 0x8d,
-	0x18, 0x7e, 0x40, 0x78, 0x63, 0x62, 0xa4, 0x17, 0xc7, 0x8a, 0x87, 0xdb, 0xb8, 0x6b, 0x44, 0xce,
-	0x85, 0xae, 0xb1, 0x63, 0x5f, 0x85, 0x9b, 0xb8, 0xa3, 0xb8, 0xa3, 0xda, 0x88, 0x3b, 0x8a, 0x87,
-	0xcf, 0x30, 0x4e, 0x15, 0x3f, 0x4d, 0x32, 0x28, 0x72, 0x1b, 0xad, 0x39, 0xda, 0x5d, 0xea, 0xe7,
-	0xab, 0xae, 0x86, 0xfa, 0xab, 0xa1, 0xcf, 0x41, 0xe5, 0x1e, 0xb4, 0x97, 0x2a, 0x7e, 0xec, 0x1c,
-	0x47, 0xeb, 0x15, 0xab, 0x0f, 0x1f, 0xee, 0xe0, 0xbb, 0x57, 0x28, 0x1a, 0xbe, 0x83, 0xaf, 0x08,
-	0xaf, 0x4d, 0x8c, 0x0c, 0x01, 0xdf, 0x69, 0x5b, 0xf3, 0xc3, 0x7f, 0xd6, 0xd3, 0x3e, 0x6f, 0x9f,
-	0xdd, 0xf0, 0x60, 0xd3, 0x38, 0x7c, 0x8d, 0xf1, 0x5f, 0x4b, 0x21, 0x6d, 0xf6, 0x95, 0xde, 0x7f,
-	0xf0, 0x7f, 0xbd, 0x49, 0x1d, 0xbf, 0x9c, 0xff, 0x22, 0xc1, 0x7c, 0x41, 0xd0, 0xe5, 0x82, 0xa0,
-	0x9f, 0x0b, 0x82, 0x3e, 0x2e, 0x49, 0x30, 0x5f, 0x12, 0x74, 0xb9, 0x24, 0xc1, 0xf7, 0x25, 0x09,
-	0xde, 0x3c, 0x92, 0xca, 0x9e, 0x15, 0x29, 0x9d, 0x42, 0xc6, 0xaa, 0xcc, 0xfd, 0x5c, 0xd8, 0x73,
-	0xd0, 0x6f, 0x5d, 0xc1, 0xca, 0x43, 0x76, 0xd1, 0x3c, 0xc2, 0xb4, 0xeb, 0x5e, 0xe1, 0x93, 0x3f,
-	0x01, 0x00, 0x00, 0xff, 0xff, 0xc0, 0x7b, 0xbe, 0x00, 0x3b, 0x03, 0x00, 0x00,
+	// 444 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x6b, 0xd4, 0x40,
+	0x18, 0xc6, 0x33, 0x5b, 0x59, 0xe8, 0x94, 0x56, 0x18, 0xfb, 0x27, 0x2e, 0x74, 0xba, 0xec, 0x41,
+	0xab, 0xd0, 0x19, 0x5a, 0xb1, 0x87, 0xe2, 0xc5, 0x5c, 0x44, 0x64, 0x41, 0x52, 0x4f, 0x5e, 0x24,
+	0xdd, 0x19, 0x66, 0x87, 0x32, 0x99, 0x65, 0x66, 0x92, 0x56, 0xbc, 0xf9, 0x09, 0xfc, 0x04, 0x7e,
+	0x06, 0x0f, 0x7e, 0x88, 0x1c, 0x3c, 0x14, 0x4f, 0xe2, 0xa1, 0xe8, 0xe6, 0xe0, 0xd7, 0x90, 0x24,
+	0x13, 0xd6, 0xae, 0x41, 0xbc, 0xe5, 0xcd, 0xef, 0x7d, 0x9f, 0xe7, 0x79, 0x5f, 0x06, 0x86, 0x99,
+	0xe2, 0x9c, 0x26, 0xd9, 0xc4, 0x49, 0x9d, 0xd2, 0xfc, 0x90, 0xba, 0x4b, 0x32, 0x33, 0xda, 0x69,
+	0x74, 0xbb, 0x22, 0xc4, 0x13, 0x92, 0x1f, 0x0e, 0xee, 0x4e, 0xb4, 0x55, 0xda, 0xbe, 0xa9, 0x31,
+	0x6d, 0x8a, 0xa6, 0x77, 0xb0, 0xd3, 0x54, 0x54, 0x59, 0x51, 0x69, 0x28, 0x2b, 0x3c, 0xd8, 0x14,
+	0x5a, 0xe8, 0x66, 0xa0, 0xfa, 0xf2, 0x7f, 0x77, 0x97, 0x4d, 0x5b, 0x97, 0x1a, 0x8f, 0x3e, 0x02,
+	0xb8, 0x3d, 0xb6, 0xe2, 0x99, 0xce, 0x4f, 0xb9, 0x8b, 0xf9, 0x45, 0x62, 0x98, 0x7d, 0x99, 0x98,
+	0x44, 0x59, 0x74, 0x0c, 0x57, 0x93, 0xcc, 0x4d, 0xb5, 0x91, 0xee, 0x6d, 0x08, 0x86, 0x60, 0x7f,
+	0x35, 0x0a, 0xbf, 0x7e, 0x3e, 0xd8, 0xf4, 0x69, 0x9e, 0x32, 0x66, 0xb8, 0xb5, 0xa7, 0xce, 0xc8,
+	0x54, 0xc4, 0x8b, 0x56, 0xf4, 0x04, 0xf6, 0x67, 0xb5, 0x42, 0xd8, 0x1b, 0x82, 0xfd, 0xb5, 0x23,
+	0x4c, 0x96, 0xb6, 0x23, 0x37, 0x7c, 0xa2, 0x5b, 0xc5, 0xf5, 0x5e, 0x10, 0xfb, 0x99, 0x93, 0x8d,
+	0xf7, 0xbf, 0x3e, 0x3d, 0x5c, 0xa8, 0x8d, 0x86, 0x10, 0x77, 0xe7, 0x8b, 0xb9, 0x9d, 0xe9, 0xd4,
+	0xf2, 0xd1, 0x3b, 0xb8, 0x3e, 0xb6, 0xc2, 0xb3, 0x48, 0x32, 0xb4, 0x0d, 0xfb, 0x96, 0xa7, 0x8c,
+	0x9b, 0x26, 0x75, 0xec, 0x2b, 0xb4, 0x01, 0x7b, 0x92, 0xd5, 0xa1, 0xd6, 0xe3, 0x9e, 0x64, 0xe8,
+	0x31, 0xec, 0x27, 0x4a, 0x67, 0xa9, 0x0b, 0x57, 0xea, 0xed, 0x76, 0xab, 0x20, 0xdf, 0xaf, 0xf7,
+	0xb6, 0x9a, 0x0d, 0x2d, 0x3b, 0x27, 0x52, 0x53, 0x95, 0xb8, 0x29, 0x79, 0x9e, 0xba, 0xd8, 0x37,
+	0x9f, 0xac, 0x55, 0x09, 0xbd, 0xe6, 0x68, 0x07, 0x6e, 0xdd, 0x30, 0x6f, 0x53, 0x1d, 0x7d, 0x01,
+	0x70, 0x65, 0x6c, 0x05, 0xd2, 0xf0, 0x4e, 0xd7, 0x71, 0xef, 0xff, 0x75, 0x94, 0xee, 0x2d, 0x07,
+	0xf4, 0x3f, 0x1b, 0x5b, 0x63, 0xf4, 0x0a, 0xc2, 0x3f, 0x6e, 0x81, 0xbb, 0xc6, 0x17, 0x7c, 0x70,
+	0xef, 0xdf, 0xbc, 0x55, 0x8d, 0x5e, 0x14, 0x3f, 0x71, 0x50, 0xcc, 0x31, 0xb8, 0x9a, 0x63, 0xf0,
+	0x63, 0x8e, 0xc1, 0x87, 0x12, 0x07, 0x45, 0x89, 0xc1, 0x55, 0x89, 0x83, 0x6f, 0x25, 0x0e, 0x5e,
+	0x3f, 0x10, 0xd2, 0x4d, 0xb3, 0x33, 0x32, 0xd1, 0x8a, 0x56, 0x9a, 0x07, 0x29, 0x77, 0x17, 0xda,
+	0x9c, 0xd7, 0x05, 0xcd, 0x8f, 0xe9, 0x65, 0xfb, 0xf4, 0xce, 0xfa, 0xf5, 0xdb, 0x7b, 0xf4, 0x3b,
+	0x00, 0x00, 0xff, 0xff, 0x3c, 0x09, 0x52, 0x39, 0x11, 0x03, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -450,11 +449,11 @@ func (m *MsgRewardsBid) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	{
-		size, err := m.BidAmount.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
+		size := m.Amount.Size()
+		i -= size
+		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
 			return 0, err
 		}
-		i -= size
 		i = encodeVarintTx(dAtA, i, uint64(size))
 	}
 	i--
@@ -545,7 +544,7 @@ func (m *MsgRewardsBid) Size() (n int) {
 	if m.Id != 0 {
 		n += 1 + sovTx(uint64(m.Id))
 	}
-	l = m.BidAmount.Size()
+	l = m.Amount.Size()
 	n += 1 + l + sovTx(uint64(l))
 	return n
 }
@@ -812,9 +811,9 @@ func (m *MsgRewardsBid) Unmarshal(dAtA []byte) error {
 			}
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BidAmount", wireType)
+				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
@@ -824,22 +823,23 @@ func (m *MsgRewardsBid) 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.BidAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex

From 14b6009dac9ca7b9cf9202a65577adca8794ebb0 Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Tue, 26 Mar 2024 14:57:37 +0100
Subject: [PATCH 2/9] checkers: number

---
 util/checkers/number.go      | 21 ++++++++++++++++
 util/checkers/number_test.go | 49 ++++++++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)

diff --git a/util/checkers/number.go b/util/checkers/number.go
index e206e4fbd7..f7fff1756f 100644
--- a/util/checkers/number.go
+++ b/util/checkers/number.go
@@ -27,6 +27,27 @@ func IntegerMaxDiff[T constraints.Integer](a, b, maxDiff T, note string) error {
 	return nil
 }
 
+func NumberMin[T constraints.Integer](a, minVal T, note string) error {
+	if a < minVal {
+		return fmt.Errorf("%s, must be at least %v", note, minVal)
+	}
+	return nil
+}
+
+func NumberPositive[T constraints.Integer](a T, note string) error {
+	if a <= 0 {
+		return fmt.Errorf("%s, must be defined and must be positive", note)
+	}
+	return nil
+}
+
+func BigNumPositive[T interface{ IsPositive() bool }](a T, note string) error {
+	if !a.IsPositive() {
+		return fmt.Errorf("%s, must be positive", note)
+	}
+	return nil
+}
+
 func DecMaxDiff(a, b, maxDiff sdk.Dec, note string) error {
 	diff := a.Sub(b).Abs()
 	if diff.GT(maxDiff) {
diff --git a/util/checkers/number_test.go b/util/checkers/number_test.go
index d7b64f3f4c..7acadd20a3 100644
--- a/util/checkers/number_test.go
+++ b/util/checkers/number_test.go
@@ -90,3 +90,52 @@ func TestDecNotNegative(t *testing.T) {
 	assert.Nil(t, DecNotNegative(sdk.ZeroDec(), ""))
 	assert.Nil(t, DecNotNegative(tsdk.DecF(5), ""))
 }
+
+func TestNumPositive(t *testing.T) {
+	assert := assert.New(t)
+
+	assert.NoError(NumberPositive(1, ""))
+	assert.NoError(NumberPositive(2, ""))
+	assert.NoError(NumberPositive(9999999999999, ""))
+
+	assert.Error(NumberPositive(0, ""))
+	assert.Error(NumberPositive(-1, ""))
+	assert.Error(NumberPositive(-2, ""))
+	assert.Error(NumberPositive(-999999999999, ""))
+
+	assert.NoError(BigNumPositive(tsdk.DecF(1.01), ""))
+	assert.NoError(BigNumPositive(tsdk.DecF(0.000001), ""))
+	assert.NoError(BigNumPositive(tsdk.DecF(0.123), ""))
+	assert.NoError(BigNumPositive(tsdk.DecF(9999999999999999999), ""))
+
+	assert.Error(BigNumPositive(tsdk.DecF(0), ""))
+	assert.Error(BigNumPositive(tsdk.DecF(-0.01), ""))
+	assert.Error(BigNumPositive(sdk.NewDec(0), ""))
+	assert.Error(BigNumPositive(sdk.NewDec(-99999999999999999), ""))
+
+	assert.NoError(BigNumPositive(sdk.NewInt(1), ""))
+	assert.NoError(BigNumPositive(sdk.NewInt(2), ""))
+	assert.NoError(BigNumPositive(sdk.NewInt(9), ""))
+	n, ok := sdk.NewIntFromString("111111119999999999999999999")
+	assert.True(ok)
+	assert.NoError(BigNumPositive(n, ""))
+}
+
+func TestNumberMin(t *testing.T) {
+	assert := assert.New(t)
+
+	assert.NoError(NumberMin(-1, -10, ""))
+	assert.NoError(NumberMin(1, 0, ""))
+	assert.NoError(NumberMin(10, 2, ""))
+	assert.NoError(NumberMin(999999999999999, 2, ""))
+	assert.NoError(NumberMin(999999999999999, 999999999999998, ""))
+	assert.NoError(NumberMin(0, 0, ""))
+	assert.NoError(NumberMin(-10, -10, ""))
+	assert.NoError(NumberMin(999999999999999, 999999999999999, ""))
+
+	assert.Error(NumberMin(-10, -1, ""))
+	assert.Error(NumberMin(-1, 10, ""))
+	assert.Error(NumberMin(-10, 0, ""))
+	assert.Error(NumberMin(-10, 10, ""))
+	assert.Error(NumberMin(10, 11, ""))
+}

From bb1634ca61b492708ec751c810df62dae51af4c5 Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Tue, 26 Mar 2024 15:13:48 +0100
Subject: [PATCH 3/9] tests in parallel

---
 util/checkers/number_test.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/util/checkers/number_test.go b/util/checkers/number_test.go
index 7acadd20a3..8324d85a59 100644
--- a/util/checkers/number_test.go
+++ b/util/checkers/number_test.go
@@ -9,6 +9,7 @@ import (
 )
 
 func TestNumberDiff(t *testing.T) {
+	t.Parallel()
 	assert := assert.New(t)
 
 	assert.NoError(IntegerMaxDiff(1, 1, 0, ""))
@@ -32,6 +33,7 @@ func TestNumberDiff(t *testing.T) {
 }
 
 func TestDecDiff(t *testing.T) {
+	t.Parallel()
 	assert := assert.New(t)
 	decMaxDiff := func(a, b, maxDiff float64) error {
 		return DecMaxDiff(tsdk.DecF(a), tsdk.DecF(b), tsdk.DecF(maxDiff), "")
@@ -61,6 +63,7 @@ func TestDecDiff(t *testing.T) {
 }
 
 func TestDecInZeroOne(t *testing.T) {
+	t.Parallel()
 	assert.NoError(t, DecInZeroOne(tsdk.DecF(0), "", true))
 	assert.NoError(t, DecInZeroOne(tsdk.DecF(0.01), "", true))
 	assert.NoError(t, DecInZeroOne(tsdk.DecF(0.999), "", true))
@@ -84,6 +87,7 @@ func TestDecInZeroOne(t *testing.T) {
 }
 
 func TestDecNotNegative(t *testing.T) {
+	t.Parallel()
 	assert.NotNil(t, DecNotNegative(tsdk.DecF(-1), ""))
 	assert.NotNil(t, DecNotNegative(sdk.Dec{}, ""))
 
@@ -92,6 +96,7 @@ func TestDecNotNegative(t *testing.T) {
 }
 
 func TestNumPositive(t *testing.T) {
+	t.Parallel()
 	assert := assert.New(t)
 
 	assert.NoError(NumberPositive(1, ""))
@@ -122,6 +127,7 @@ func TestNumPositive(t *testing.T) {
 }
 
 func TestNumberMin(t *testing.T) {
+	t.Parallel()
 	assert := assert.New(t)
 
 	assert.NoError(NumberMin(-1, -10, ""))

From e249de46e6944b14f5de5a7396bdbbcad95e738d Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Tue, 26 Mar 2024 15:37:16 +0100
Subject: [PATCH 4/9] msgs implementation and tests

---
 x/auction/msgs.go      | 58 +++++++++++++++++++++++++++++++++
 x/auction/msgs_test.go | 74 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 132 insertions(+)
 create mode 100644 x/auction/msgs.go
 create mode 100644 x/auction/msgs_test.go

diff --git a/x/auction/msgs.go b/x/auction/msgs.go
new file mode 100644
index 0000000000..db18b0367d
--- /dev/null
+++ b/x/auction/msgs.go
@@ -0,0 +1,58 @@
+package auction
+
+import (
+	"errors"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/umee-network/umee/v6/util/checkers"
+)
+
+var (
+	_ sdk.Msg = &MsgGovSetRewardsParams{}
+	_ sdk.Msg = &MsgRewardsBid{}
+)
+
+const minBidDuration = 3600 // 1h in seconds
+
+//
+// MsgGovSetRewardsParams
+//
+
+// ValidateBasic implements Msg
+func (msg *MsgGovSetRewardsParams) ValidateBasic() error {
+	errs := checkers.AssertGovAuthority(msg.Authority)
+	return errors.Join(errs, checkers.NumberMin(msg.Params.BidDuration, minBidDuration, "bid_duration"))
+}
+
+func (msg *MsgGovSetRewardsParams) GetSigners() []sdk.AccAddress {
+	return checkers.Signers(msg.Authority)
+}
+
+// LegacyMsg.Type implementations
+func (msg MsgGovSetRewardsParams) Route() string { return "" }
+func (msg MsgGovSetRewardsParams) Type() string  { return sdk.MsgTypeURL(&msg) }
+func (msg *MsgGovSetRewardsParams) GetSignBytes() []byte {
+	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg))
+}
+
+//
+// MsgRewardsBid
+//
+
+// ValidateBasic implements Msg
+func (msg *MsgRewardsBid) ValidateBasic() error {
+	errs := checkers.ValidateAddr(msg.Sender, "sender")
+	errs = errors.Join(errs, checkers.NumberPositive(msg.Id, "auction ID"))
+	return errors.Join(errs, checkers.BigNumPositive(msg.Amount, "bid_amount"))
+}
+
+func (msg *MsgRewardsBid) GetSigners() []sdk.AccAddress {
+	return checkers.Signers(msg.Sender)
+}
+
+// LegacyMsg.Type implementations
+func (msg MsgRewardsBid) Route() string { return "" }
+func (msg MsgRewardsBid) Type() string  { return sdk.MsgTypeURL(&msg) }
+func (msg *MsgRewardsBid) GetSignBytes() []byte {
+	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg))
+}
diff --git a/x/auction/msgs_test.go b/x/auction/msgs_test.go
new file mode 100644
index 0000000000..1ae90a5a44
--- /dev/null
+++ b/x/auction/msgs_test.go
@@ -0,0 +1,74 @@
+package auction
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/umee-network/umee/v6/tests/accs"
+	"github.com/umee-network/umee/v6/tests/tcheckers"
+	"github.com/umee-network/umee/v6/util/checkers"
+)
+
+func TestMsgGovSetRewardsParams(t *testing.T) {
+	t.Parallel()
+	validMsg := MsgGovSetRewardsParams{
+		Authority: checkers.GovModuleAddr,
+		Params:    RewardsParams{BidDuration: 3600 * 12}, // 12h
+	}
+
+	invalidAuth := validMsg
+	invalidAuth.Authority = accs.Bob.String()
+
+	invalidBidDuration1 := validMsg
+	invalidBidDuration1.Params.BidDuration = 0
+
+	invalidBidDuration2 := validMsg
+	invalidBidDuration2.Params.BidDuration = 1200
+
+	tcs := []struct {
+		name   string
+		msg    MsgGovSetRewardsParams
+		errMsg string
+	}{
+		{"valid msg", validMsg, ""},
+		{"wrong gov auth", invalidAuth, "expected gov account"},
+		{"bid duration 0", invalidBidDuration1, "must be at least"},
+		{"bid duration 1200", invalidBidDuration2, "must be at least"},
+	}
+	for _, tc := range tcs {
+		tcheckers.ErrorContains(t, tc.msg.ValidateBasic(), tc.errMsg, tc.name)
+	}
+}
+
+func TestMsgRewardsBid(t *testing.T) {
+	t.Parallel()
+	validMsg := MsgRewardsBid{
+		Sender: accs.Alice.String(),
+		Id:     12,
+		Amount: sdk.NewInt(123),
+	}
+
+	invalid := validMsg
+	invalid.Sender = "not a valid acc"
+	invalid.Id = 0
+	invalid.Amount = sdk.ZeroInt()
+
+	invalidAmount := validMsg
+	invalidAmount.Amount = sdk.NewInt(-100)
+
+	tcs := []struct {
+		name   string
+		msg    MsgRewardsBid
+		errMsg string
+	}{
+		{"valid msg", validMsg, ""},
+		{"invalid sender", invalid, "sender"},
+		{"invalid ID", invalid, "auction ID"},
+		{"amount zero", invalid, "bid_amount: must be positive"},
+		{"amount negative", invalidAmount, "bid_amount: must be positive"},
+	}
+	for _, tc := range tcs {
+		tcheckers.ErrorContains(t, tc.msg.ValidateBasic(), tc.errMsg, tc.name)
+	}
+}

From 19ea1b99435816e10ae381cb80a9f7b3724a9fce Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Tue, 26 Mar 2024 15:38:11 +0100
Subject: [PATCH 5/9] update checkers messages

---
 util/checkers/number.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/util/checkers/number.go b/util/checkers/number.go
index f7fff1756f..408d212970 100644
--- a/util/checkers/number.go
+++ b/util/checkers/number.go
@@ -22,28 +22,28 @@ func IntegerMaxDiff[T constraints.Integer](a, b, maxDiff T, note string) error {
 		diff = b - a
 	}
 	if diff > maxDiff {
-		return fmt.Errorf("%s, diff (=%v) is too big", note, diff)
+		return fmt.Errorf("%s: diff (=%v) is too big", note, diff)
 	}
 	return nil
 }
 
 func NumberMin[T constraints.Integer](a, minVal T, note string) error {
 	if a < minVal {
-		return fmt.Errorf("%s, must be at least %v", note, minVal)
+		return fmt.Errorf("%s: must be at least %v", note, minVal)
 	}
 	return nil
 }
 
 func NumberPositive[T constraints.Integer](a T, note string) error {
 	if a <= 0 {
-		return fmt.Errorf("%s, must be defined and must be positive", note)
+		return fmt.Errorf("%s: must be defined and must be positive", note)
 	}
 	return nil
 }
 
 func BigNumPositive[T interface{ IsPositive() bool }](a T, note string) error {
 	if !a.IsPositive() {
-		return fmt.Errorf("%s, must be positive", note)
+		return fmt.Errorf("%s: must be positive", note)
 	}
 	return nil
 }
@@ -51,7 +51,7 @@ func BigNumPositive[T interface{ IsPositive() bool }](a T, note string) error {
 func DecMaxDiff(a, b, maxDiff sdk.Dec, note string) error {
 	diff := a.Sub(b).Abs()
 	if diff.GT(maxDiff) {
-		return fmt.Errorf("%s, diff (=%v) is too big", note, diff)
+		return fmt.Errorf("%s: diff (=%v) is too big", note, diff)
 	}
 	return nil
 }

From e70b79aea6d2d07f428b1447d1ab5fc7236cc19a Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Wed, 27 Mar 2024 17:38:53 +0100
Subject: [PATCH 6/9] comment

---
 proto/umee/auction/v1/tx.proto | 2 +-
 x/auction/tx.pb.go             | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/proto/umee/auction/v1/tx.proto b/proto/umee/auction/v1/tx.proto
index 48054370f4..f46f9dfea7 100644
--- a/proto/umee/auction/v1/tx.proto
+++ b/proto/umee/auction/v1/tx.proto
@@ -42,7 +42,7 @@ message MsgRewardsBid {
   string sender = 1;
   // the current auction ID being bid on. Fails if the ID is not an ID of the current auction.
   uint32 id = 2;
-  // amount of the bid in the base tokens
+  // amount of the bid in the bond base tokens (uumee)
   string amount = 3 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.nullable) = false];
 }
 
diff --git a/x/auction/tx.pb.go b/x/auction/tx.pb.go
index 0984d36205..a9cdb8bab3 100644
--- a/x/auction/tx.pb.go
+++ b/x/auction/tx.pb.go
@@ -121,7 +121,7 @@ type MsgRewardsBid struct {
 	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
 	// the current auction ID being bid on. Fails if the ID is not an ID of the current auction.
 	Id uint32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
-	// amount of the bid in the base tokens
+	// amount of the bid in the bond base tokens (uumee)
 	Amount cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
 }
 

From 8b8158f33d29573027ee719774def6f7e164a3d1 Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Wed, 27 Mar 2024 17:43:24 +0100
Subject: [PATCH 7/9] use coin for bid amount

---
 proto/umee/auction/v1/genesis.proto |  10 ++-
 proto/umee/auction/v1/tx.proto      |   4 +-
 x/auction/genesis.pb.go             | 123 +++++++++++++++++++---------
 x/auction/tx.pb.go                  |  78 +++++++++---------
 4 files changed, 132 insertions(+), 83 deletions(-)

diff --git a/proto/umee/auction/v1/genesis.proto b/proto/umee/auction/v1/genesis.proto
index 3feb87d9d1..7a1dda9823 100644
--- a/proto/umee/auction/v1/genesis.proto
+++ b/proto/umee/auction/v1/genesis.proto
@@ -18,11 +18,13 @@ message GenesisState {
   // Latest active (in bid phase) reward auction.
   uint32 reward_auction_id = 2;
   // Latest highest bid.
-  string highest_bidder = 3 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+  string                   highest_bidder = 3 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+  cosmos.base.v1beta1.Coin highest_bid    = 4 [(gogoproto.nullable) = false];
+
   // Tokens collected for the current auction.
-  repeated cosmos.base.v1beta1.Coin current_rewards = 4 [(gogoproto.nullable) = false];
+  repeated cosmos.base.v1beta1.Coin current_rewards = 5 [(gogoproto.nullable) = false];
   // Tokens collected for the next auction, while the current reward auction is still in the
   // bid phase.
-  repeated cosmos.base.v1beta1.Coin next_rewards                = 5 [(gogoproto.nullable) = false];
-  google.protobuf.Timestamp         current_rewards_auction_end = 6 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+  repeated cosmos.base.v1beta1.Coin next_rewards                = 6 [(gogoproto.nullable) = false];
+  google.protobuf.Timestamp         current_rewards_auction_end = 7 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
 }
diff --git a/proto/umee/auction/v1/tx.proto b/proto/umee/auction/v1/tx.proto
index f46f9dfea7..21f10822d9 100644
--- a/proto/umee/auction/v1/tx.proto
+++ b/proto/umee/auction/v1/tx.proto
@@ -2,6 +2,7 @@ syntax = "proto3";
 package umee.auction.v1;
 
 import "cosmos_proto/cosmos.proto";
+import "cosmos/base/v1beta1/coin.proto";
 import "cosmos/msg/v1/msg.proto";
 import "gogoproto/gogo.proto";
 import "umee/auction/v1/auction.proto";
@@ -9,7 +10,6 @@ import "umee/auction/v1/auction.proto";
 option go_package                      = "github.com/umee-network/umee/v6/x/auction";
 option (gogoproto.goproto_getters_all) = false;
 option (gogoproto.messagename_all)     = true;
-
 // Msg defines the x/auction module's Msg service.
 service Msg {
   //
@@ -43,7 +43,7 @@ message MsgRewardsBid {
   // the current auction ID being bid on. Fails if the ID is not an ID of the current auction.
   uint32 id = 2;
   // amount of the bid in the bond base tokens (uumee)
-  string amount = 3 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.nullable) = false];
+  cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false];
 }
 
 // MsgRewardsBidResponse response type for Msg/RewardsBid
diff --git a/x/auction/genesis.pb.go b/x/auction/genesis.pb.go
index 5dcc536ab2..18f94d3d82 100644
--- a/x/auction/genesis.pb.go
+++ b/x/auction/genesis.pb.go
@@ -35,13 +35,14 @@ type GenesisState struct {
 	// Latest active (in bid phase) reward auction.
 	RewardAuctionId uint32 `protobuf:"varint,2,opt,name=reward_auction_id,json=rewardAuctionId,proto3" json:"reward_auction_id,omitempty"`
 	// Latest highest bid.
-	HighestBidder string `protobuf:"bytes,3,opt,name=highest_bidder,json=highestBidder,proto3" json:"highest_bidder,omitempty"`
+	HighestBidder string     `protobuf:"bytes,3,opt,name=highest_bidder,json=highestBidder,proto3" json:"highest_bidder,omitempty"`
+	HighestBid    types.Coin `protobuf:"bytes,4,opt,name=highest_bid,json=highestBid,proto3" json:"highest_bid"`
 	// Tokens collected for the current auction.
-	CurrentRewards []types.Coin `protobuf:"bytes,4,rep,name=current_rewards,json=currentRewards,proto3" json:"current_rewards"`
+	CurrentRewards []types.Coin `protobuf:"bytes,5,rep,name=current_rewards,json=currentRewards,proto3" json:"current_rewards"`
 	// Tokens collected for the next auction, while the current reward auction is still in the
 	// bid phase.
-	NextRewards              []types.Coin `protobuf:"bytes,5,rep,name=next_rewards,json=nextRewards,proto3" json:"next_rewards"`
-	CurrentRewardsAuctionEnd time.Time    `protobuf:"bytes,6,opt,name=current_rewards_auction_end,json=currentRewardsAuctionEnd,proto3,stdtime" json:"current_rewards_auction_end"`
+	NextRewards              []types.Coin `protobuf:"bytes,6,rep,name=next_rewards,json=nextRewards,proto3" json:"next_rewards"`
+	CurrentRewardsAuctionEnd time.Time    `protobuf:"bytes,7,opt,name=current_rewards_auction_end,json=currentRewardsAuctionEnd,proto3,stdtime" json:"current_rewards_auction_end"`
 }
 
 func (m *GenesisState) Reset()         { *m = GenesisState{} }
@@ -84,35 +85,36 @@ func init() {
 func init() { proto.RegisterFile("umee/auction/v1/genesis.proto", fileDescriptor_15e83c50dcf6ac7b) }
 
 var fileDescriptor_15e83c50dcf6ac7b = []byte{
-	// 441 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xcf, 0x6e, 0xd3, 0x40,
-	0x10, 0xc6, 0x6d, 0x52, 0x2a, 0x70, 0x9a, 0x44, 0x58, 0x3d, 0xb8, 0x41, 0x6c, 0x22, 0x4e, 0x01,
-	0xa9, 0xbb, 0x4a, 0x91, 0xb8, 0xa2, 0x1a, 0xa1, 0x82, 0xb8, 0x20, 0x97, 0x13, 0x17, 0xcb, 0xf6,
-	0x0e, 0x9b, 0x15, 0x78, 0x37, 0xda, 0x5d, 0xa7, 0x7d, 0x8c, 0x3e, 0x0c, 0x37, 0x5e, 0x20, 0xc7,
-	0x8a, 0x13, 0x27, 0xfe, 0x24, 0x2f, 0x82, 0xbc, 0xbb, 0xe6, 0x4f, 0xb8, 0xf4, 0xe6, 0x99, 0x6f,
-	0xbe, 0xd1, 0x6f, 0x3f, 0x4f, 0xf4, 0xa0, 0xa9, 0x01, 0x48, 0xd1, 0x54, 0x86, 0x4b, 0x41, 0x56,
-	0x73, 0xc2, 0x40, 0x80, 0xe6, 0x1a, 0x2f, 0x95, 0x34, 0x32, 0x1e, 0xb5, 0x32, 0xf6, 0x32, 0x5e,
-	0xcd, 0xc7, 0x13, 0x26, 0x25, 0xfb, 0x08, 0xc4, 0xca, 0x65, 0xf3, 0x9e, 0x18, 0x5e, 0x83, 0x36,
-	0x45, 0xbd, 0x74, 0x8e, 0xf1, 0x51, 0x25, 0x75, 0x2d, 0x75, 0x6e, 0x2b, 0xe2, 0x0a, 0x2f, 0x21,
-	0x57, 0x91, 0xb2, 0xd0, 0x40, 0x56, 0xf3, 0x12, 0x4c, 0x31, 0x27, 0x95, 0xe4, 0xc2, 0xeb, 0x87,
-	0x4c, 0x32, 0xe9, 0x7c, 0xed, 0x97, 0xef, 0xfe, 0x47, 0xd8, 0xd1, 0x58, 0xf9, 0xe1, 0xe7, 0x5e,
-	0x74, 0x70, 0xe6, 0x98, 0xcf, 0x4d, 0x61, 0x20, 0x7e, 0x1d, 0x0d, 0x15, 0x5c, 0x14, 0x8a, 0xea,
-	0x7c, 0x59, 0xa8, 0xa2, 0xd6, 0x49, 0x38, 0x0d, 0x67, 0xfd, 0x13, 0x84, 0x77, 0xde, 0x82, 0x33,
-	0x37, 0xf6, 0xc6, 0x4e, 0xa5, 0x7b, 0xeb, 0x6f, 0x93, 0x20, 0x1b, 0xa8, 0xbf, 0x9b, 0xf1, 0xe3,
-	0xe8, 0x9e, 0x6b, 0xe4, 0xde, 0x97, 0x73, 0x9a, 0xdc, 0x9a, 0x86, 0xb3, 0x41, 0x36, 0x72, 0xc2,
-	0xa9, 0xeb, 0xbf, 0xa2, 0xf1, 0xb3, 0x68, 0xb8, 0xe0, 0x6c, 0x01, 0xda, 0xe4, 0x25, 0xa7, 0x14,
-	0x54, 0xd2, 0x9b, 0x86, 0xb3, 0xbb, 0x69, 0xf2, 0xe5, 0xd3, 0xf1, 0xa1, 0x0f, 0xe2, 0x94, 0x52,
-	0x05, 0x5a, 0x9f, 0x1b, 0xc5, 0x05, 0xcb, 0x06, 0x7e, 0x3e, 0xb5, 0xe3, 0xf1, 0xcb, 0x68, 0x54,
-	0x35, 0x4a, 0x81, 0x30, 0xb9, 0xa7, 0x48, 0xf6, 0xa6, 0xbd, 0x59, 0xff, 0xe4, 0x08, 0x7b, 0x7b,
-	0x9b, 0x1c, 0xf6, 0xc9, 0xe1, 0xe7, 0x92, 0x0b, 0x4f, 0x3d, 0xf4, 0x3e, 0xff, 0xa2, 0x38, 0x8d,
-	0x0e, 0x04, 0x5c, 0xfe, 0x59, 0x73, 0xfb, 0x66, 0x6b, 0xfa, 0xad, 0xa9, 0xdb, 0x51, 0x45, 0xf7,
-	0x77, 0x68, 0x7e, 0x67, 0x00, 0x82, 0x26, 0xfb, 0x36, 0xd4, 0x31, 0x76, 0xf7, 0x80, 0xbb, 0x7b,
-	0xc0, 0x6f, 0xbb, 0x7b, 0x48, 0xef, 0xb4, 0x3b, 0xaf, 0xbe, 0x4f, 0xc2, 0x2c, 0xf9, 0x17, 0xcf,
-	0x47, 0xf6, 0x42, 0xd0, 0xf4, 0x6c, 0xfd, 0x13, 0x05, 0xeb, 0x0d, 0x0a, 0xaf, 0x37, 0x28, 0xfc,
-	0xb1, 0x41, 0xe1, 0xd5, 0x16, 0x05, 0xd7, 0x5b, 0x14, 0x7c, 0xdd, 0xa2, 0xe0, 0xdd, 0x23, 0xc6,
-	0xcd, 0xa2, 0x29, 0x71, 0x25, 0x6b, 0xd2, 0xfe, 0xbc, 0x63, 0x01, 0xe6, 0x42, 0xaa, 0x0f, 0xb6,
-	0x20, 0xab, 0xa7, 0xe4, 0xb2, 0x3b, 0x86, 0x72, 0xdf, 0x02, 0x3c, 0xf9, 0x15, 0x00, 0x00, 0xff,
-	0xff, 0x68, 0x1c, 0x46, 0x71, 0xd0, 0x02, 0x00, 0x00,
+	// 453 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0xcd, 0x6e, 0x13, 0x3d,
+	0x14, 0x9d, 0xf9, 0xd2, 0xaf, 0x80, 0xd3, 0x24, 0x62, 0xd4, 0xc5, 0x34, 0x08, 0x27, 0x62, 0x15,
+	0x90, 0x6a, 0x2b, 0x20, 0xb1, 0x85, 0x0e, 0x42, 0x05, 0xb1, 0x41, 0x53, 0x56, 0x6c, 0x46, 0x33,
+	0xe3, 0xcb, 0xc4, 0x82, 0xb1, 0x23, 0xdb, 0x93, 0xf6, 0x31, 0xfa, 0x30, 0x3c, 0x44, 0x96, 0x15,
+	0x2b, 0x56, 0xfc, 0x24, 0xcf, 0x81, 0x84, 0xc6, 0xf6, 0xd0, 0x52, 0x36, 0xdd, 0xf9, 0xde, 0x73,
+	0xcf, 0xd1, 0xb9, 0xc7, 0x17, 0xdd, 0x6f, 0x6a, 0x00, 0x9a, 0x37, 0xa5, 0xe1, 0x52, 0xd0, 0xd5,
+	0x9c, 0x56, 0x20, 0x40, 0x73, 0x4d, 0x96, 0x4a, 0x1a, 0x19, 0x8d, 0x5a, 0x98, 0x78, 0x98, 0xac,
+	0xe6, 0xe3, 0x49, 0x25, 0x65, 0xf5, 0x09, 0xa8, 0x85, 0x8b, 0xe6, 0x03, 0x35, 0xbc, 0x06, 0x6d,
+	0xf2, 0x7a, 0xe9, 0x18, 0xe3, 0x83, 0x52, 0xea, 0x5a, 0xea, 0xcc, 0x56, 0xd4, 0x15, 0x1e, 0xc2,
+	0xae, 0xa2, 0x45, 0xae, 0x81, 0xae, 0xe6, 0x05, 0x98, 0x7c, 0x4e, 0x4b, 0xc9, 0x85, 0xc7, 0xf7,
+	0x2b, 0x59, 0x49, 0xc7, 0x6b, 0x5f, 0xbe, 0xfb, 0x8f, 0xc3, 0xce, 0x8d, 0x85, 0x1f, 0xfc, 0xea,
+	0xa1, 0xbd, 0x63, 0xe7, 0xf9, 0xc4, 0xe4, 0x06, 0xa2, 0x37, 0x68, 0xa8, 0xe0, 0x34, 0x57, 0x4c,
+	0x67, 0xcb, 0x5c, 0xe5, 0xb5, 0x8e, 0xc3, 0x69, 0x38, 0xeb, 0x3f, 0xc6, 0xe4, 0xda, 0x2e, 0x24,
+	0x75, 0x63, 0x6f, 0xed, 0x54, 0xb2, 0xb3, 0xfe, 0x36, 0x09, 0xd2, 0x81, 0xba, 0xda, 0x8c, 0x1e,
+	0xa1, 0xbb, 0xae, 0x91, 0x79, 0x5e, 0xc6, 0x59, 0xfc, 0xdf, 0x34, 0x9c, 0x0d, 0xd2, 0x91, 0x03,
+	0x8e, 0x5c, 0xff, 0x35, 0x8b, 0x9e, 0xa1, 0xe1, 0x82, 0x57, 0x0b, 0xd0, 0x26, 0x2b, 0x38, 0x63,
+	0xa0, 0xe2, 0xde, 0x34, 0x9c, 0xdd, 0x49, 0xe2, 0x2f, 0x9f, 0x0f, 0xf7, 0x7d, 0x10, 0x47, 0x8c,
+	0x29, 0xd0, 0xfa, 0xc4, 0x28, 0x2e, 0xaa, 0x74, 0xe0, 0xe7, 0x13, 0x3b, 0x1e, 0x3d, 0x47, 0xfd,
+	0x2b, 0x02, 0xf1, 0x8e, 0xb5, 0x7d, 0x40, 0x3c, 0xb5, 0x4d, 0x8d, 0xf8, 0xd4, 0xc8, 0x0b, 0xc9,
+	0x85, 0x77, 0x8c, 0x2e, 0x45, 0xa2, 0x57, 0x68, 0x54, 0x36, 0x4a, 0x81, 0x30, 0x99, 0xdf, 0x23,
+	0xfe, 0x7f, 0xda, 0xbb, 0x89, 0xca, 0xd0, 0xf3, 0x7c, 0x26, 0x51, 0x82, 0xf6, 0x04, 0x9c, 0x5d,
+	0xca, 0xec, 0xde, 0x4c, 0xa6, 0xdf, 0x92, 0x3a, 0x8d, 0x12, 0xdd, 0xbb, 0xe6, 0xe6, 0x4f, 0x8a,
+	0x20, 0x58, 0x7c, 0xcb, 0xee, 0x37, 0x26, 0xee, 0xa2, 0x48, 0x77, 0x51, 0xe4, 0x5d, 0x77, 0x51,
+	0xc9, 0xed, 0x56, 0xf3, 0xfc, 0xfb, 0x24, 0x4c, 0xe3, 0xbf, 0xed, 0xf9, 0xd0, 0x5f, 0x0a, 0x96,
+	0x1c, 0xaf, 0x7f, 0xe2, 0x60, 0xbd, 0xc1, 0xe1, 0xc5, 0x06, 0x87, 0x3f, 0x36, 0x38, 0x3c, 0xdf,
+	0xe2, 0xe0, 0x62, 0x8b, 0x83, 0xaf, 0x5b, 0x1c, 0xbc, 0x7f, 0x58, 0x71, 0xb3, 0x68, 0x0a, 0x52,
+	0xca, 0x9a, 0xb6, 0xdf, 0x7f, 0x28, 0xc0, 0x9c, 0x4a, 0xf5, 0xd1, 0x16, 0x74, 0xf5, 0x94, 0x9e,
+	0x75, 0xe7, 0x54, 0xec, 0x5a, 0x03, 0x4f, 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x78, 0xdf, 0x45,
+	0x2b, 0x12, 0x03, 0x00, 0x00,
 }
 
 func (m *GenesisState) Marshal() (dAtA []byte, err error) {
@@ -142,7 +144,7 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i -= n1
 	i = encodeVarintGenesis(dAtA, i, uint64(n1))
 	i--
-	dAtA[i] = 0x32
+	dAtA[i] = 0x3a
 	if len(m.NextRewards) > 0 {
 		for iNdEx := len(m.NextRewards) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -154,7 +156,7 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 				i = encodeVarintGenesis(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x2a
+			dAtA[i] = 0x32
 		}
 	}
 	if len(m.CurrentRewards) > 0 {
@@ -168,9 +170,19 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 				i = encodeVarintGenesis(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x22
+			dAtA[i] = 0x2a
+		}
+	}
+	{
+		size, err := m.HighestBid.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
+		i -= size
+		i = encodeVarintGenesis(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0x22
 	if len(m.HighestBidder) > 0 {
 		i -= len(m.HighestBidder)
 		copy(dAtA[i:], m.HighestBidder)
@@ -222,6 +234,8 @@ func (m *GenesisState) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovGenesis(uint64(l))
 	}
+	l = m.HighestBid.Size()
+	n += 1 + l + sovGenesis(uint64(l))
 	if len(m.CurrentRewards) > 0 {
 		for _, e := range m.CurrentRewards {
 			l = e.Size()
@@ -359,6 +373,39 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
 			m.HighestBidder = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HighestBid", 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.HighestBid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field CurrentRewards", wireType)
 			}
@@ -392,7 +439,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
+		case 6:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field NextRewards", wireType)
 			}
@@ -426,7 +473,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 6:
+		case 7:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field CurrentRewardsAuctionEnd", wireType)
 			}
diff --git a/x/auction/tx.pb.go b/x/auction/tx.pb.go
index a9cdb8bab3..2851660e40 100644
--- a/x/auction/tx.pb.go
+++ b/x/auction/tx.pb.go
@@ -5,9 +5,9 @@ package auction
 
 import (
 	context "context"
-	cosmossdk_io_math "cosmossdk.io/math"
 	fmt "fmt"
 	_ "github.com/cosmos/cosmos-proto"
+	types "github.com/cosmos/cosmos-sdk/types"
 	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
 	_ "github.com/cosmos/gogoproto/gogoproto"
 	grpc1 "github.com/cosmos/gogoproto/grpc"
@@ -122,7 +122,7 @@ type MsgRewardsBid struct {
 	// the current auction ID being bid on. Fails if the ID is not an ID of the current auction.
 	Id uint32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
 	// amount of the bid in the bond base tokens (uumee)
-	Amount cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
+	Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"`
 }
 
 func (m *MsgRewardsBid) Reset()         { *m = MsgRewardsBid{} }
@@ -212,35 +212,36 @@ func init() {
 func init() { proto.RegisterFile("umee/auction/v1/tx.proto", fileDescriptor_44a5dea2889d94ea) }
 
 var fileDescriptor_44a5dea2889d94ea = []byte{
-	// 444 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x6b, 0xd4, 0x40,
-	0x18, 0xc6, 0x33, 0x5b, 0x59, 0xe8, 0x94, 0x56, 0x18, 0xfb, 0x27, 0x2e, 0x74, 0xba, 0xec, 0x41,
-	0xab, 0xd0, 0x19, 0x5a, 0xb1, 0x87, 0xe2, 0xc5, 0x5c, 0x44, 0x64, 0x41, 0x52, 0x4f, 0x5e, 0x24,
-	0xdd, 0x19, 0x66, 0x87, 0x32, 0x99, 0x65, 0x66, 0x92, 0x56, 0xbc, 0xf9, 0x09, 0xfc, 0x04, 0x7e,
-	0x06, 0x0f, 0x7e, 0x88, 0x1c, 0x3c, 0x14, 0x4f, 0xe2, 0xa1, 0xe8, 0xe6, 0xe0, 0xd7, 0x90, 0x24,
-	0x13, 0xd6, 0xae, 0x41, 0xbc, 0xe5, 0xcd, 0xef, 0x7d, 0x9f, 0xe7, 0x79, 0x5f, 0x06, 0x86, 0x99,
-	0xe2, 0x9c, 0x26, 0xd9, 0xc4, 0x49, 0x9d, 0xd2, 0xfc, 0x90, 0xba, 0x4b, 0x32, 0x33, 0xda, 0x69,
-	0x74, 0xbb, 0x22, 0xc4, 0x13, 0x92, 0x1f, 0x0e, 0xee, 0x4e, 0xb4, 0x55, 0xda, 0xbe, 0xa9, 0x31,
-	0x6d, 0x8a, 0xa6, 0x77, 0xb0, 0xd3, 0x54, 0x54, 0x59, 0x51, 0x69, 0x28, 0x2b, 0x3c, 0xd8, 0x14,
-	0x5a, 0xe8, 0x66, 0xa0, 0xfa, 0xf2, 0x7f, 0x77, 0x97, 0x4d, 0x5b, 0x97, 0x1a, 0x8f, 0x3e, 0x02,
-	0xb8, 0x3d, 0xb6, 0xe2, 0x99, 0xce, 0x4f, 0xb9, 0x8b, 0xf9, 0x45, 0x62, 0x98, 0x7d, 0x99, 0x98,
-	0x44, 0x59, 0x74, 0x0c, 0x57, 0x93, 0xcc, 0x4d, 0xb5, 0x91, 0xee, 0x6d, 0x08, 0x86, 0x60, 0x7f,
-	0x35, 0x0a, 0xbf, 0x7e, 0x3e, 0xd8, 0xf4, 0x69, 0x9e, 0x32, 0x66, 0xb8, 0xb5, 0xa7, 0xce, 0xc8,
-	0x54, 0xc4, 0x8b, 0x56, 0xf4, 0x04, 0xf6, 0x67, 0xb5, 0x42, 0xd8, 0x1b, 0x82, 0xfd, 0xb5, 0x23,
-	0x4c, 0x96, 0xb6, 0x23, 0x37, 0x7c, 0xa2, 0x5b, 0xc5, 0xf5, 0x5e, 0x10, 0xfb, 0x99, 0x93, 0x8d,
-	0xf7, 0xbf, 0x3e, 0x3d, 0x5c, 0xa8, 0x8d, 0x86, 0x10, 0x77, 0xe7, 0x8b, 0xb9, 0x9d, 0xe9, 0xd4,
-	0xf2, 0xd1, 0x3b, 0xb8, 0x3e, 0xb6, 0xc2, 0xb3, 0x48, 0x32, 0xb4, 0x0d, 0xfb, 0x96, 0xa7, 0x8c,
-	0x9b, 0x26, 0x75, 0xec, 0x2b, 0xb4, 0x01, 0x7b, 0x92, 0xd5, 0xa1, 0xd6, 0xe3, 0x9e, 0x64, 0xe8,
-	0x31, 0xec, 0x27, 0x4a, 0x67, 0xa9, 0x0b, 0x57, 0xea, 0xed, 0x76, 0xab, 0x20, 0xdf, 0xaf, 0xf7,
-	0xb6, 0x9a, 0x0d, 0x2d, 0x3b, 0x27, 0x52, 0x53, 0x95, 0xb8, 0x29, 0x79, 0x9e, 0xba, 0xd8, 0x37,
-	0x9f, 0xac, 0x55, 0x09, 0xbd, 0xe6, 0x68, 0x07, 0x6e, 0xdd, 0x30, 0x6f, 0x53, 0x1d, 0x7d, 0x01,
-	0x70, 0x65, 0x6c, 0x05, 0xd2, 0xf0, 0x4e, 0xd7, 0x71, 0xef, 0xff, 0x75, 0x94, 0xee, 0x2d, 0x07,
-	0xf4, 0x3f, 0x1b, 0x5b, 0x63, 0xf4, 0x0a, 0xc2, 0x3f, 0x6e, 0x81, 0xbb, 0xc6, 0x17, 0x7c, 0x70,
-	0xef, 0xdf, 0xbc, 0x55, 0x8d, 0x5e, 0x14, 0x3f, 0x71, 0x50, 0xcc, 0x31, 0xb8, 0x9a, 0x63, 0xf0,
-	0x63, 0x8e, 0xc1, 0x87, 0x12, 0x07, 0x45, 0x89, 0xc1, 0x55, 0x89, 0x83, 0x6f, 0x25, 0x0e, 0x5e,
-	0x3f, 0x10, 0xd2, 0x4d, 0xb3, 0x33, 0x32, 0xd1, 0x8a, 0x56, 0x9a, 0x07, 0x29, 0x77, 0x17, 0xda,
-	0x9c, 0xd7, 0x05, 0xcd, 0x8f, 0xe9, 0x65, 0xfb, 0xf4, 0xce, 0xfa, 0xf5, 0xdb, 0x7b, 0xf4, 0x3b,
-	0x00, 0x00, 0xff, 0xff, 0x3c, 0x09, 0x52, 0x39, 0x11, 0x03, 0x00, 0x00,
+	// 452 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x6a, 0x14, 0x31,
+	0x18, 0xc7, 0x27, 0x5b, 0x59, 0x68, 0x4a, 0x2b, 0xc4, 0xda, 0x4e, 0x17, 0x8c, 0xcb, 0x1e, 0xb4,
+	0x0a, 0x4d, 0xd8, 0x0a, 0x15, 0x8a, 0x17, 0xd7, 0x83, 0x07, 0x59, 0x90, 0xa9, 0x27, 0x2f, 0x92,
+	0xdd, 0x09, 0x69, 0x90, 0xc9, 0xb7, 0x24, 0x99, 0x69, 0x3d, 0x78, 0xf1, 0x09, 0x7c, 0x02, 0x9f,
+	0xc1, 0x83, 0x0f, 0xb1, 0x07, 0x0f, 0xc5, 0x93, 0x27, 0xd1, 0xdd, 0x83, 0xaf, 0x21, 0x33, 0x93,
+	0x61, 0x6d, 0x1d, 0xa4, 0xb7, 0xf9, 0xe6, 0xf7, 0xe5, 0xff, 0xfd, 0xf2, 0x11, 0x1c, 0xe7, 0x99,
+	0x94, 0x5c, 0xe4, 0x53, 0xaf, 0xc1, 0xf0, 0x62, 0xc8, 0xfd, 0x39, 0x9b, 0x59, 0xf0, 0x40, 0x6e,
+	0x96, 0x84, 0x05, 0xc2, 0x8a, 0x61, 0x6f, 0x6f, 0x0a, 0x2e, 0x03, 0xf7, 0xa6, 0xc2, 0xbc, 0x2e,
+	0xea, 0xde, 0x1e, 0xad, 0x2b, 0x3e, 0x11, 0x4e, 0xf2, 0x62, 0x38, 0x91, 0x5e, 0x0c, 0xf9, 0x14,
+	0xb4, 0x09, 0x7c, 0x37, 0xf0, 0xcc, 0xa9, 0x72, 0x46, 0xe6, 0x54, 0x00, 0xdb, 0x0a, 0x14, 0xd4,
+	0x81, 0xe5, 0x57, 0xf8, 0x7b, 0xe7, 0xaa, 0x54, 0x63, 0x51, 0xe1, 0xc1, 0x27, 0x84, 0x77, 0xc6,
+	0x4e, 0x3d, 0x87, 0xe2, 0x44, 0xfa, 0x44, 0x9e, 0x09, 0x9b, 0xba, 0x97, 0xc2, 0x8a, 0xcc, 0x91,
+	0x23, 0xbc, 0x2e, 0x72, 0x7f, 0x0a, 0x56, 0xfb, 0x77, 0x31, 0xea, 0xa3, 0xfd, 0xf5, 0x51, 0xfc,
+	0xed, 0xcb, 0xc1, 0x76, 0xb0, 0x7d, 0x9a, 0xa6, 0x56, 0x3a, 0x77, 0xe2, 0xad, 0x36, 0x2a, 0x59,
+	0xb5, 0x92, 0x27, 0xb8, 0x3b, 0xab, 0x12, 0xe2, 0x4e, 0x1f, 0xed, 0x6f, 0x1c, 0x52, 0x76, 0xe5,
+	0xf6, 0xec, 0xd2, 0x9c, 0xd1, 0x8d, 0xf9, 0x8f, 0xbb, 0x51, 0x12, 0xce, 0x1c, 0x6f, 0x7d, 0xf8,
+	0xfd, 0xf9, 0xe1, 0x2a, 0x6d, 0xd0, 0xc7, 0xb4, 0xdd, 0x2f, 0x91, 0x6e, 0x06, 0xc6, 0xc9, 0xc1,
+	0x7b, 0xbc, 0x39, 0x76, 0x2a, 0xb0, 0x91, 0x4e, 0xc9, 0x0e, 0xee, 0x3a, 0x69, 0x52, 0x69, 0x6b,
+	0xeb, 0x24, 0x54, 0x64, 0x0b, 0x77, 0x74, 0x5a, 0x49, 0x6d, 0x26, 0x1d, 0x9d, 0x92, 0xc7, 0xb8,
+	0x2b, 0x32, 0xc8, 0x8d, 0x8f, 0xd7, 0x2a, 0xd1, 0x3d, 0x16, 0xae, 0x56, 0xae, 0x9e, 0x85, 0xd5,
+	0xb3, 0x67, 0xa0, 0x4d, 0xe3, 0x58, 0xb7, 0x1f, 0x6f, 0x94, 0x8e, 0x21, 0x75, 0xb0, 0x8b, 0x6f,
+	0x5f, 0x1a, 0xdf, 0x78, 0x1d, 0x7e, 0x45, 0x78, 0x6d, 0xec, 0x14, 0x01, 0x7c, 0xab, 0x6d, 0xbd,
+	0xf7, 0xff, 0x59, 0x4b, 0xfb, 0x3d, 0x7b, 0xfc, 0x9a, 0x8d, 0xcd, 0x60, 0xf2, 0x0a, 0xe3, 0xbf,
+	0xb6, 0x41, 0xdb, 0x8e, 0xaf, 0x78, 0xef, 0xde, 0xff, 0x79, 0x93, 0x3a, 0x7a, 0x31, 0xff, 0x45,
+	0xa3, 0xf9, 0x82, 0xa2, 0x8b, 0x05, 0x45, 0x3f, 0x17, 0x14, 0x7d, 0x5c, 0xd2, 0x68, 0xbe, 0xa4,
+	0xe8, 0x62, 0x49, 0xa3, 0xef, 0x4b, 0x1a, 0xbd, 0x7e, 0xa0, 0xb4, 0x3f, 0xcd, 0x27, 0x6c, 0x0a,
+	0x19, 0x2f, 0x33, 0x0f, 0x8c, 0xf4, 0x67, 0x60, 0xdf, 0x56, 0x05, 0x2f, 0x8e, 0xf8, 0x79, 0xf3,
+	0xf8, 0x26, 0xdd, 0xea, 0xf5, 0x3d, 0xfa, 0x13, 0x00, 0x00, 0xff, 0xff, 0x99, 0x65, 0xe1, 0x57,
+	0x33, 0x03, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -449,11 +450,11 @@ func (m *MsgRewardsBid) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	{
-		size := m.Amount.Size()
-		i -= size
-		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
+		size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
 			return 0, err
 		}
+		i -= size
 		i = encodeVarintTx(dAtA, i, uint64(size))
 	}
 	i--
@@ -813,7 +814,7 @@ func (m *MsgRewardsBid) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				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
@@ -823,16 +824,15 @@ func (m *MsgRewardsBid) 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
 			}

From 3f5d854fca1873fa060af59ff3125f5f51d2a4ec Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Thu, 28 Mar 2024 00:55:20 +0100
Subject: [PATCH 8/9] update msgs

---
 util/coin/fixtures.go  |  1 +
 x/auction/msgs.go      |  8 +++++++-
 x/auction/msgs_test.go | 15 ++++++++++-----
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/util/coin/fixtures.go b/util/coin/fixtures.go
index ac02855dff..e1ab80638b 100644
--- a/util/coin/fixtures.go
+++ b/util/coin/fixtures.go
@@ -12,6 +12,7 @@ const umee = appparams.BondDenom
 var (
 	// the uToken denom "u/uumee"
 	UumeeDenom = ToUTokenDenom(umee)
+	UmeeDenom  = umee
 	// 1uumee Coin
 	Umee1 = New(umee, 1)
 	// 10_000uumee Coin
diff --git a/x/auction/msgs.go b/x/auction/msgs.go
index db18b0367d..f7002f8b37 100644
--- a/x/auction/msgs.go
+++ b/x/auction/msgs.go
@@ -4,6 +4,8 @@ import (
 	"errors"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	appparams "github.com/umee-network/umee/v6/app/params"
 	"github.com/umee-network/umee/v6/util/checkers"
 )
 
@@ -43,7 +45,11 @@ func (msg *MsgGovSetRewardsParams) GetSignBytes() []byte {
 func (msg *MsgRewardsBid) ValidateBasic() error {
 	errs := checkers.ValidateAddr(msg.Sender, "sender")
 	errs = errors.Join(errs, checkers.NumberPositive(msg.Id, "auction ID"))
-	return errors.Join(errs, checkers.BigNumPositive(msg.Amount, "bid_amount"))
+	errs = errors.Join(errs, checkers.BigNumPositive(msg.Amount.Amount, "bid_amount"))
+	if msg.Amount.Denom != appparams.BondDenom {
+		errs = errors.Join(errs, errors.New("bid amount must be in "+appparams.BondDenom))
+	}
+	return errs
 }
 
 func (msg *MsgRewardsBid) GetSigners() []sdk.AccAddress {
diff --git a/x/auction/msgs_test.go b/x/auction/msgs_test.go
index 1ae90a5a44..057af5d913 100644
--- a/x/auction/msgs_test.go
+++ b/x/auction/msgs_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/umee-network/umee/v6/tests/accs"
 	"github.com/umee-network/umee/v6/tests/tcheckers"
 	"github.com/umee-network/umee/v6/util/checkers"
+	"github.com/umee-network/umee/v6/util/coin"
 )
 
 func TestMsgGovSetRewardsParams(t *testing.T) {
@@ -46,16 +47,19 @@ func TestMsgRewardsBid(t *testing.T) {
 	validMsg := MsgRewardsBid{
 		Sender: accs.Alice.String(),
 		Id:     12,
-		Amount: sdk.NewInt(123),
+		Amount: coin.Umee10k,
 	}
 
 	invalid := validMsg
 	invalid.Sender = "not a valid acc"
 	invalid.Id = 0
-	invalid.Amount = sdk.ZeroInt()
+	invalid.Amount.Amount = sdk.ZeroInt()
 
-	invalidAmount := validMsg
-	invalidAmount.Amount = sdk.NewInt(-100)
+	invalidAmount1 := validMsg
+	invalidAmount1.Amount.Amount = sdk.NewInt(-100)
+
+	invalidDenom := validMsg
+	invalidDenom.Amount.Denom = "other"
 
 	tcs := []struct {
 		name   string
@@ -66,7 +70,8 @@ func TestMsgRewardsBid(t *testing.T) {
 		{"invalid sender", invalid, "sender"},
 		{"invalid ID", invalid, "auction ID"},
 		{"amount zero", invalid, "bid_amount: must be positive"},
-		{"amount negative", invalidAmount, "bid_amount: must be positive"},
+		{"amount negative", invalidAmount1, "bid_amount: must be positive"},
+		{"wrong denom", invalidDenom, "bid amount must be in " + coin.UmeeDenom},
 	}
 	for _, tc := range tcs {
 		tcheckers.ErrorContains(t, tc.msg.ValidateBasic(), tc.errMsg, tc.name)

From 31998a53170384579cac23d981cf62e710787196 Mon Sep 17 00:00:00 2001
From: Robert Zaremba <robert@zaremba.ch>
Date: Thu, 28 Mar 2024 10:28:00 +0100
Subject: [PATCH 9/9] update coin fixtures

---
 util/coin/fixtures.go  | 8 ++++++--
 x/auction/msgs_test.go | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/util/coin/fixtures.go b/util/coin/fixtures.go
index 89761bfdaf..63a7c295a1 100644
--- a/util/coin/fixtures.go
+++ b/util/coin/fixtures.go
@@ -12,7 +12,6 @@ const umee = appparams.BondDenom
 //
 //revive:disable:var-naming
 var (
-	UmeeDenom  = umee
 	// the uToken denom "u/uumee"
 	U_umee = ToUTokenDenom(umee) //nolint:stylecheck
 	// 1uumee Coin
@@ -42,7 +41,12 @@ var (
 
 //revive:enable:var-naming
 
-// UmeeCoins creates an Umee (uumee) sdk.Coins with given amount
+// Umee creates a BondDenom sdk.Coin with the given amount
+func Umee(amount int64) sdk.Coin {
+	return sdk.NewInt64Coin(umee, amount)
+}
+
+// UmeeCoins creates an Umee (uumee) sdk.Coins with the given amount
 func UmeeCoins(amount int64) sdk.Coins {
 	return sdk.NewCoins(sdk.NewInt64Coin(umee, amount))
 }
diff --git a/x/auction/msgs_test.go b/x/auction/msgs_test.go
index 057af5d913..29728561a0 100644
--- a/x/auction/msgs_test.go
+++ b/x/auction/msgs_test.go
@@ -71,7 +71,7 @@ func TestMsgRewardsBid(t *testing.T) {
 		{"invalid ID", invalid, "auction ID"},
 		{"amount zero", invalid, "bid_amount: must be positive"},
 		{"amount negative", invalidAmount1, "bid_amount: must be positive"},
-		{"wrong denom", invalidDenom, "bid amount must be in " + coin.UmeeDenom},
+		{"wrong denom", invalidDenom, "bid amount must be in " + validMsg.Amount.Denom},
 	}
 	for _, tc := range tcs {
 		tcheckers.ErrorContains(t, tc.msg.ValidateBasic(), tc.errMsg, tc.name)