fixes + test hw edge cases

CLI tests, updates, fixes (reflect hw options)
add hardware args to cli lease creation
2022-09-23 00:16:42 +00:00 · 2022-09-22 23:59:03 +00:00 · 2022-09-22 23:43:15 +00:00 · 2022-09-22 23:18:08 +00:00 · 2022-09-22 23:01:31 +00:00 · 2022-09-22 22:40:51 +00:00
15 changed files with 501 additions and 88 deletions
--- a/config.yml
+++ b/config.yml
@ -30,7 +30,17 @@ genesis:
        gpuModels:
          gtx-1050-ti: 0
          gtx-1650-ti: 0
-
+        auctionTime: 10
+        minLeasePeriod: 3600
+        maxLeasePeriod: 2678400
+        allowedAuctionDenoms:
+          - uclr
+          - uusdc
+        maxVerifiedProviders: 1000
+        providerMinLockedUClr: 500000000
+        providerLockedSlashUClr: 100000000
+        providerAuditFrequency: 400
+        providerAuditLength: 11
 accounts:
  - name: alice
    coins: ["20000000000uusdc", "200000000000uclr"]
--- a/docs/static/openapi.yml
+++ b/docs/static/openapi.yml
@ -176,6 +176,9 @@ paths:
                      items:
                        type: string
                      title: hardware specs
+                    cpuCores:
+                      type: string
+                      format: uint64
                    cpuArch:
                      type: string
                      enum:
@ -341,6 +344,9 @@ paths:
                    items:
                      type: string
                    title: hardware specs
+                  cpuCores:
+                    type: string
+                    format: uint64
                  cpuArch:
                    type: string
                    enum:
@ -30960,6 +30966,9 @@ definitions:
        items:
          type: string
        title: hardware specs
+      cpuCores:
+        type: string
+        format: uint64
      cpuArch:
        type: string
        enum:
@ -31119,6 +31128,9 @@ definitions:
              items:
                type: string
              title: hardware specs
+            cpuCores:
+              type: string
+              format: uint64
            cpuArch:
              type: string
              enum:
@ -31226,6 +31238,9 @@ definitions:
            items:
              type: string
            title: hardware specs
+          cpuCores:
+            type: string
+            format: uint64
          cpuArch:
            type: string
            enum:
--- a/go.mod
+++ b/go.mod
@ -88,7 +88,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
--- a/go.sum
+++ b/go.sum
@ -734,8 +734,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=
--- a/proto/colinearcore/auction.proto
+++ b/proto/colinearcore/auction.proto
@ -20,7 +20,8 @@ message Auction {
  string remaining = 11;
  // hardware specs
  repeated string gpus = 12;
-  CpuArchitecture cpuArch = 13;
-  uint64 memMb = 14;
-  uint64 storageGb = 15;
+  uint64 cpuCores = 13;
+  CpuArchitecture cpuArch = 14;
+  uint64 memMb = 15;
+  uint64 storageGb = 16;
 }
--- a/proto/colinearcore/tx.proto
+++ b/proto/colinearcore/tx.proto
@ -5,6 +5,8 @@ package colinear.colinearcore;

 option go_package = "colinear/x/colinearcore/types";

+import "colinearcore/hardware.proto";
+
 // Msg defines the Msg service.
 service Msg {
      rpc NewAuction(MsgNewAuction) returns (MsgNewAuctionResponse);
@ -26,6 +28,12 @@ message MsgNewAuction {
  // verified providers just specifies who's allowed to bid on the lease auction.
  // STORED IN MEMORY. DOES NOT GET WRITTEN TO CHAIN STATE.
  repeated string verifiedProviders = 7;
+  // hardware specs (mandatory)
+  repeated string gpus = 8;
+  uint64 cpuCores = 9;
+  CpuArchitecture cpuArch = 10;
+  uint64 memMb = 11;
+  uint64 storageGb = 12;
 }

 message MsgNewAuctionResponse {
--- a/tests/test_auction_flow.sh
+++ b/tests/test_auction_flow.sh
@ -10,16 +10,34 @@ colineard tx colinearcore unlock-all-funds -y --from alice \
 | swallow "Unlock all funds before proceeding"

 colineard tx colinearcore new-auction asdf asdf 2000 uusdc $(now + 3500) \
+    '[]' '["gtx-1050-ti"]' 4 0 1000 50 \
    -y --from bob \
    | expect_fail "Can't create auction below min lease period" 

 colineard tx colinearcore new-auction asdf asdf 2000 uusdc $(now + 8200000) \
+    '[]' '["gtx-1050-ti"]' 4 0 1000 50 \
    -y --from bob \
    | expect_fail "Can't create auction above max lease period" 

+colineard tx colinearcore new-auction asdf asdf 2000 uusdc $(now + 3700) \
+    '[]' '[]' 4 0 1000 50 \
+    -y --from bob \
+    | expect_fail "Can't create an auction with 0 GPUs" 
+
+colineard tx colinearcore new-auction asdf asdf 2000 uusdc $(now + 3700) \
+    '[]' '["gtx-1050-ti"]' 0 0 1000 50 \
+    -y --from bob \
+    | expect_fail "Can't create an auction with 0 cores" 
+
+colineard tx colinearcore new-auction asdf asdf 2000 uusdc $(now + 3700) \
+    '[]' '["gtx-1050-ti"]' 0 0 1000 50 \
+    -y --from bob \
+    | expect_fail "Can't create an auction with sub-25GB storage" 
+
 before=$(get_balance $BOB uusdc)

 colineard tx colinearcore new-auction asdf asdf 2000 uusdc $(now + 3700) \
+    '[]' '["gtx-1050-ti"]' 4 0 1000 50 \
    -y --from bob \
    | expect_success "New auction is created" 

--- a/tests/test_auction_flow_verified.sh
+++ b/tests/test_auction_flow_verified.sh
@ -17,7 +17,7 @@ colineard tx colinearcore lock-funds 550000000 -y --from bob \
    | expect_success "Re-lock funds (Bob)"

 colineard tx colinearcore new-auction asdf asdf 200 uusdc $(now + 3700) \
-    $ALICE \
+    '["'$ALICE'"]' '["gtx-1050-ti"]' 4 0 1000 50 \
    -y --from bob \
    | expect_success "New auction is created" 

--- a/x/colinearcore/client/cli/tx_new_auction.go
+++ b/x/colinearcore/client/cli/tx_new_auction.go
@ -1,6 +1,7 @@
 package cli

 import (
+	"encoding/json"
 	"strconv"

 	"colinear/x/colinearcore/types"
@ -15,12 +16,12 @@ var _ = strconv.Itoa(0)

 func CmdNewAuction() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "new-auction [name] [description] [ceiling] [denom] [end date] [verified providers (separated by spaces)...]",
+		Use:   "new-auction [name] [description] [ceiling] [denom] [end date] [verified providers (json string)] [gpus (json string)] [cpu cores] [cpu arch] [memory (MB)] [storage (GB)]",
 		Short: "Broadcast message newAuction",
-		// Args:  cobra.ExactArgs(5),
+		Args:  cobra.ExactArgs(11),
 		// below: we're hardcoding the max providers param since we
 		// can't check chain params locally
-		Args: cobra.RangeArgs(5, 1005),
+		// Args: cobra.RangeArgs(10, 1010),
 		RunE: func(cmd *cobra.Command, args []string) (err error) {
 			argName := args[0]
 			argDescription := args[1]
@ -28,23 +29,56 @@ func CmdNewAuction() *cobra.Command {
 			argDenom := args[3]
 			argLeaseEnd := args[4]

+			vProvString := args[5]
+			gpusString := args[6]
+			cpuCores := args[7]
+			cpuArch := args[8]
+			memMb := args[9]
+			storageGb := args[10]
+
 			verifiedProviders := []string{}
-			if len(args) >= 6 {
-				// set to remaining arguments
-				verifiedProviders = args[5:]
-			}
+			gpuModels := []string{}

 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
 				return err
 			}

+			// try to marshal JSON lists
+			if err := json.Unmarshal([]byte(vProvString), &verifiedProviders); err != nil {
+				return err
+			}
+			if err := json.Unmarshal([]byte(gpusString), &gpuModels); err != nil {
+				return err
+			}
+
+			// try to parse int strings
+
 			var le int
 			le, err = strconv.Atoi(argLeaseEnd)
 			if err != nil {
 				return err
 			}

+			nCpuCores, err := strconv.Atoi(cpuCores)
+			if err != nil {
+				return err
+			}
+
+			nCpuArch, err := strconv.Atoi(cpuArch)
+			if err != nil {
+				return err
+			}
+			nMemMb, err := strconv.Atoi(memMb)
+			if err != nil {
+				return err
+			}
+
+			nStorageGb, err := strconv.Atoi(storageGb)
+			if err != nil {
+				return err
+			}
+
 			msg := types.NewMsgNewAuction(
 				clientCtx.GetFromAddress().String(),
 				argName,
@ -53,6 +87,11 @@ func CmdNewAuction() *cobra.Command {
 				argDenom,
 				uint64(le),
 				verifiedProviders,
+				gpuModels,
+				uint64(nCpuCores),
+				types.CpuArchitecture(nCpuArch),
+				uint64(nMemMb),
+				uint64(nStorageGb),
 			)
 			if err := msg.ValidateBasic(); err != nil {
 				return err
--- a/x/colinearcore/keeper/msg_server_new_auction.go
+++ b/x/colinearcore/keeper/msg_server_new_auction.go
@ -2,6 +2,7 @@ package keeper

 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
@ -87,6 +88,16 @@ found:
 		LeaseEnd: msg.LeaseEnd,
 		// remaining payout -> null
 		// Remaining:  "0",
+		Gpus:      msg.Gpus,
+		CpuArch:   msg.CpuArch,
+		CpuCores:  msg.CpuCores,
+		MemMb:     msg.MemMb,
+		StorageGb: msg.StorageGb,
+	}
+
+	// validate hardware
+	if err := k.ValidateAuctionHardware(ctx, auction); err != nil {
+		return nil, err
 	}

 	spendable := k.bank.SpendableCoins(ctx, senderAddr)
@ -111,12 +122,22 @@ found:

 	k.Keeper.SetNextAuction(ctx, types.NextAuction{AuctionId: next.AuctionId})

+	gpuList, err := json.Marshal(msg.Gpus)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal gpu list %v", msg.Gpus)
+	}
+
 	ctx.EventManager().EmitEvent(
 		sdk.NewEvent(
 			types.AuctionCreatedEventType,
 			sdk.NewAttribute(types.AuctionCreatedIndex, auction.Index),
 			sdk.NewAttribute(types.AuctionCreatedEventCreator, msg.Creator),
 			sdk.NewAttribute(types.AuctionCreatedCeiling, msg.Ceiling),
+			sdk.NewAttribute(types.AuctionCreatedCpuCores, msg.CpuArch.String()),
+			sdk.NewAttribute(types.AuctionCreatedCpuArch, msg.CpuArch.String()),
+			sdk.NewAttribute(types.AuctionCreatedGpus, string(gpuList)),
+			sdk.NewAttribute(types.AuctionCreatedMemMb, fmt.Sprint(msg.MemMb)),
+			sdk.NewAttribute(types.AuctionCreatedStorage, fmt.Sprint(msg.StorageGb)),
 		),
 	)

@ -124,3 +145,33 @@ found:
 		AuctionId: strconv.FormatUint(next.AuctionId, 10),
 	}, nil
 }
+
+func (k *Keeper) ValidateAuctionHardware(ctx sdk.Context, a types.Auction) error {
+
+	if a.Gpus == nil {
+		return errors.New("GPU list not found")
+	}
+
+	// move these to module params later
+	if len(a.Gpus) == 0 || len(a.Gpus) > 20 {
+		return fmt.Errorf("must order between 1 and 20 GPUs (got %d)", len(a.Gpus))
+	}
+
+	for _, gpu := range a.Gpus {
+		if _, ok := k.GetParams(ctx).GpuModels[gpu]; !ok {
+			return fmt.Errorf("GPU model %s invalid", gpu)
+		}
+	}
+
+	// move these to module params later
+	if a.CpuCores < 1 || a.CpuCores > 12 {
+		return fmt.Errorf("CPU Cores must be between 1 and 12 (got %d)", a.CpuCores)
+	}
+
+	// move these to module params later
+	if a.StorageGb < 25 || a.StorageGb > 2000 {
+		return fmt.Errorf("storage must be between 25GB and 2TB (got %dGB)", a.StorageGb)
+	}
+
+	return nil
+}
--- a/x/colinearcore/types/auction.pb.go
+++ b/x/colinearcore/types/auction.pb.go
@ -36,9 +36,10 @@ type Auction struct {
 	Remaining   string `protobuf:"bytes,11,opt,name=remaining,proto3" json:"remaining,omitempty"`
 	// hardware specs
 	Gpus      []string        `protobuf:"bytes,12,rep,name=gpus,proto3" json:"gpus,omitempty"`
-	CpuArch   CpuArchitecture `protobuf:"varint,13,opt,name=cpuArch,proto3,enum=colinear.colinearcore.CpuArchitecture" json:"cpuArch,omitempty"`
-	MemMb     uint64          `protobuf:"varint,14,opt,name=memMb,proto3" json:"memMb,omitempty"`
-	StorageGb uint64          `protobuf:"varint,15,opt,name=storageGb,proto3" json:"storageGb,omitempty"`
+	CpuCores  uint64          `protobuf:"varint,13,opt,name=cpuCores,proto3" json:"cpuCores,omitempty"`
+	CpuArch   CpuArchitecture `protobuf:"varint,14,opt,name=cpuArch,proto3,enum=colinear.colinearcore.CpuArchitecture" json:"cpuArch,omitempty"`
+	MemMb     uint64          `protobuf:"varint,15,opt,name=memMb,proto3" json:"memMb,omitempty"`
+	StorageGb uint64          `protobuf:"varint,16,opt,name=storageGb,proto3" json:"storageGb,omitempty"`
 }

 func (m *Auction) Reset()         { *m = Auction{} }
@ -158,6 +159,13 @@ func (m *Auction) GetGpus() []string {
 	return nil
 }

+func (m *Auction) GetCpuCores() uint64 {
+	if m != nil {
+		return m.CpuCores
+	}
+	return 0
+}
+
 func (m *Auction) GetCpuArch() CpuArchitecture {
 	if m != nil {
 		return m.CpuArch
@ -186,31 +194,32 @@ func init() {
 func init() { proto.RegisterFile("colinearcore/auction.proto", fileDescriptor_c2581508d43e9c55) }

 var fileDescriptor_c2581508d43e9c55 = []byte{
-	// 380 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xb1, 0xae, 0xd3, 0x30,
-	0x14, 0x86, 0x6b, 0x9a, 0x36, 0xad, 0x0b, 0x45, 0xb2, 0x00, 0x59, 0x01, 0xa2, 0x88, 0x01, 0x65,
-	0x4a, 0xa5, 0x32, 0xb0, 0xd2, 0x22, 0xc4, 0xc4, 0x12, 0x36, 0x36, 0xc7, 0x3e, 0x6a, 0x2d, 0x35,
-	0x76, 0xe4, 0x38, 0x6a, 0x79, 0x0b, 0x1e, 0x0b, 0x89, 0xa5, 0x23, 0xe3, 0x55, 0xfb, 0x22, 0x57,
-	0xb6, 0x95, 0xdb, 0x56, 0xba, 0x77, 0xf3, 0xff, 0xff, 0xe7, 0xf8, 0x7c, 0x3e, 0x32, 0x4e, 0xb8,
-	0xde, 0x49, 0x05, 0xcc, 0x70, 0x6d, 0x60, 0xc1, 0x3a, 0x6e, 0xa5, 0x56, 0x45, 0x63, 0xb4, 0xd5,
-	0xe4, 0x75, 0x9f, 0x15, 0xd7, 0x45, 0xc9, 0x9b, 0x9b, 0x96, 0x4a, 0x8a, 0x50, 0x9e, 0xbc, 0xbd,
-	0xf1, 0xb7, 0xcc, 0x88, 0x3d, 0x33, 0x10, 0xc2, 0x0f, 0xff, 0x86, 0x38, 0x5e, 0x85, 0xdb, 0xc9,
-	0x2b, 0x3c, 0x92, 0x4a, 0xc0, 0x81, 0xa2, 0x0c, 0xe5, 0xd3, 0x32, 0x08, 0x42, 0x70, 0xa4, 0x58,
-	0x0d, 0xf4, 0x99, 0x37, 0xfd, 0x99, 0x64, 0x78, 0x26, 0xa0, 0xe5, 0x46, 0x36, 0xae, 0x91, 0x0e,
-	0x7d, 0x74, 0x6d, 0x91, 0x02, 0x47, 0x15, 0xb4, 0x96, 0x46, 0x19, 0xca, 0x67, 0xcb, 0xa4, 0x78,
-	0x14, 0xb9, 0x58, 0x4b, 0x51, 0xfa, 0x3a, 0x92, 0xe0, 0x89, 0x00, 0x26, 0x5c, 0x46, 0x47, 0x19,
-	0xca, 0xa3, 0xf2, 0x41, 0x13, 0x8a, 0x63, 0x0e, 0x72, 0x27, 0xd5, 0x86, 0x8e, 0xfd, 0xa4, 0x5e,
-	0x3a, 0x62, 0x01, 0x4a, 0xd7, 0x34, 0x0e, 0xc4, 0x5e, 0x38, 0x57, 0xef, 0x15, 0x18, 0x3a, 0x09,
-	0xae, 0x17, 0x24, 0xc5, 0x78, 0x07, 0xac, 0x85, 0x9f, 0x96, 0x19, 0x4b, 0xa7, 0x7e, 0xc6, 0x95,
-	0xe3, 0x08, 0xbc, 0xfa, 0xa6, 0x04, 0xc5, 0x81, 0xa0, 0xd7, 0xe4, 0x1d, 0x9e, 0x1a, 0xa8, 0x99,
-	0x54, 0x8e, 0x61, 0xe6, 0x6f, 0xbd, 0x18, 0x6e, 0x43, 0x9b, 0xa6, 0x6b, 0xe9, 0xf3, 0x6c, 0xe8,
-	0x36, 0xe4, 0xce, 0xe4, 0x0b, 0x8e, 0x79, 0xd3, 0xad, 0x0c, 0xdf, 0xd2, 0x17, 0x19, 0xca, 0xe7,
-	0xcb, 0x8f, 0x4f, 0xac, 0xe0, 0x6b, 0xa8, 0x92, 0x16, 0xb8, 0xed, 0x0c, 0x94, 0x7d, 0x9b, 0x7b,
-	0x45, 0x0d, 0xf5, 0x8f, 0x8a, 0xce, 0x3d, 0x4c, 0x10, 0x8e, 0xa4, 0xb5, 0xda, 0xb0, 0x0d, 0x7c,
-	0xaf, 0xe8, 0x4b, 0x9f, 0x5c, 0x8c, 0xf5, 0xe7, 0xbf, 0xa7, 0x14, 0x1d, 0x4f, 0x29, 0xba, 0x3b,
-	0xa5, 0xe8, 0xcf, 0x39, 0x1d, 0x1c, 0xcf, 0xe9, 0xe0, 0xff, 0x39, 0x1d, 0xfc, 0x7a, 0xdf, 0x0f,
-	0x5d, 0x1c, 0x16, 0x37, 0xff, 0xc1, 0xfe, 0x6e, 0xa0, 0xad, 0xc6, 0xfe, 0x37, 0x7c, 0xba, 0x0f,
-	0x00, 0x00, 0xff, 0xff, 0x29, 0x90, 0xf6, 0xec, 0x77, 0x02, 0x00, 0x00,
+	// 392 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0xc1, 0x8e, 0xd3, 0x30,
+	0x10, 0xad, 0x69, 0x76, 0xb3, 0x75, 0x61, 0x41, 0x16, 0xa0, 0x51, 0x80, 0x28, 0xe2, 0x80, 0x72,
+	0x4a, 0xa5, 0xe5, 0xc0, 0x95, 0xdd, 0x15, 0xe2, 0xc4, 0x25, 0xdc, 0xb8, 0x39, 0xf6, 0xa8, 0xb5,
+	0xd4, 0xd8, 0x91, 0xe3, 0xa8, 0xe5, 0x2f, 0xf8, 0x2c, 0x8e, 0x3d, 0x72, 0x44, 0xed, 0x81, 0xdf,
+	0x40, 0xb6, 0x15, 0xda, 0x4a, 0xec, 0xcd, 0xef, 0xbd, 0x99, 0x37, 0xcf, 0xa3, 0xa1, 0x99, 0x30,
+	0x6b, 0xa5, 0x91, 0x5b, 0x61, 0x2c, 0x2e, 0xf8, 0x20, 0x9c, 0x32, 0xba, 0xea, 0xac, 0x71, 0x86,
+	0xbd, 0x18, 0xb5, 0xea, 0xb4, 0x28, 0x7b, 0x79, 0xd6, 0xd2, 0x28, 0x19, 0xcb, 0xb3, 0x57, 0x67,
+	0xfc, 0x8a, 0x5b, 0xb9, 0xe1, 0x16, 0xa3, 0xf8, 0xf6, 0xcf, 0x94, 0xa6, 0xb7, 0xd1, 0x9d, 0x3d,
+	0xa7, 0x17, 0x4a, 0x4b, 0xdc, 0x02, 0x29, 0x48, 0x39, 0xab, 0x23, 0x60, 0x8c, 0x26, 0x9a, 0xb7,
+	0x08, 0x8f, 0x02, 0x19, 0xde, 0xac, 0xa0, 0x73, 0x89, 0xbd, 0xb0, 0xaa, 0xf3, 0x8d, 0x30, 0x0d,
+	0xd2, 0x29, 0xc5, 0x2a, 0x9a, 0x34, 0xd8, 0x3b, 0x48, 0x0a, 0x52, 0xce, 0x6f, 0xb2, 0xea, 0xbf,
+	0x91, 0xab, 0x3b, 0x25, 0xeb, 0x50, 0xc7, 0x32, 0x7a, 0x25, 0x91, 0x4b, 0xaf, 0xc1, 0x45, 0x41,
+	0xca, 0xa4, 0xfe, 0x87, 0x19, 0xd0, 0x54, 0xa0, 0x5a, 0x2b, 0xbd, 0x84, 0xcb, 0x30, 0x69, 0x84,
+	0x3e, 0xb1, 0x44, 0x6d, 0x5a, 0x48, 0x63, 0xe2, 0x00, 0x3c, 0x6b, 0x36, 0x1a, 0x2d, 0x5c, 0x45,
+	0x36, 0x00, 0x96, 0x53, 0xba, 0x46, 0xde, 0xe3, 0x57, 0xc7, 0xad, 0x83, 0x59, 0x98, 0x71, 0xc2,
+	0xf8, 0x04, 0x01, 0x7d, 0xd2, 0x12, 0x68, 0x4c, 0x30, 0x62, 0xf6, 0x9a, 0xce, 0x2c, 0xb6, 0x5c,
+	0x69, 0x9f, 0x61, 0x1e, 0x5c, 0x8f, 0x84, 0xdf, 0xd0, 0xb2, 0x1b, 0x7a, 0x78, 0x5c, 0x4c, 0xfd,
+	0x86, 0xfc, 0xdb, 0xbb, 0x89, 0x6e, 0xb8, 0x37, 0x16, 0x7b, 0x78, 0x12, 0xdd, 0x46, 0xcc, 0x3e,
+	0xd2, 0x54, 0x74, 0xc3, 0xad, 0x15, 0x2b, 0xb8, 0x2e, 0x48, 0x79, 0x7d, 0xf3, 0xee, 0x81, 0xf5,
+	0xdc, 0xc7, 0x2a, 0xe5, 0x50, 0xb8, 0xc1, 0x62, 0x3d, 0xb6, 0xf9, 0x1f, 0xb6, 0xd8, 0x7e, 0x69,
+	0xe0, 0x69, 0xb0, 0x8e, 0xc0, 0xa7, 0xec, 0x9d, 0xb1, 0x7c, 0x89, 0x9f, 0x1b, 0x78, 0x16, 0x94,
+	0x23, 0x71, 0xf7, 0xe1, 0xe7, 0x3e, 0x27, 0xbb, 0x7d, 0x4e, 0x7e, 0xef, 0x73, 0xf2, 0xe3, 0x90,
+	0x4f, 0x76, 0x87, 0x7c, 0xf2, 0xeb, 0x90, 0x4f, 0xbe, 0xbd, 0x19, 0x87, 0x2e, 0xb6, 0x8b, 0xb3,
+	0x5b, 0x71, 0xdf, 0x3b, 0xec, 0x9b, 0xcb, 0x70, 0x29, 0xef, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff,
+	0x68, 0xb2, 0x60, 0x4d, 0x93, 0x02, 0x00, 0x00,
 }

 func (m *Auction) Marshal() (dAtA []byte, err error) {
@ -236,16 +245,23 @@ func (m *Auction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if m.StorageGb != 0 {
 		i = encodeVarintAuction(dAtA, i, uint64(m.StorageGb))
 		i--
-		dAtA[i] = 0x78
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x80
 	}
 	if m.MemMb != 0 {
 		i = encodeVarintAuction(dAtA, i, uint64(m.MemMb))
 		i--
-		dAtA[i] = 0x70
+		dAtA[i] = 0x78
 	}
 	if m.CpuArch != 0 {
 		i = encodeVarintAuction(dAtA, i, uint64(m.CpuArch))
 		i--
+		dAtA[i] = 0x70
+	}
+	if m.CpuCores != 0 {
+		i = encodeVarintAuction(dAtA, i, uint64(m.CpuCores))
+		i--
 		dAtA[i] = 0x68
 	}
 	if len(m.Gpus) > 0 {
@ -400,6 +416,9 @@ func (m *Auction) Size() (n int) {
 			n += 1 + l + sovAuction(uint64(l))
 		}
 	}
+	if m.CpuCores != 0 {
+		n += 1 + sovAuction(uint64(m.CpuCores))
+	}
 	if m.CpuArch != 0 {
 		n += 1 + sovAuction(uint64(m.CpuArch))
 	}
@ -407,7 +426,7 @@ func (m *Auction) Size() (n int) {
 		n += 1 + sovAuction(uint64(m.MemMb))
 	}
 	if m.StorageGb != 0 {
-		n += 1 + sovAuction(uint64(m.StorageGb))
+		n += 2 + sovAuction(uint64(m.StorageGb))
 	}
 	return n
 }
@ -797,6 +816,25 @@ func (m *Auction) Unmarshal(dAtA []byte) error {
 			m.Gpus = append(m.Gpus, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		case 13:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CpuCores", wireType)
+			}
+			m.CpuCores = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuction
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CpuCores |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 14:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field CpuArch", wireType)
 			}
@ -815,7 +853,7 @@ func (m *Auction) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 14:
+		case 15:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field MemMb", wireType)
 			}
@ -834,7 +872,7 @@ func (m *Auction) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 15:
+		case 16:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field StorageGb", wireType)
 			}
--- a/x/colinearcore/types/keys.go
+++ b/x/colinearcore/types/keys.go
@ -37,10 +37,11 @@ const (
 	AuctionCreatedIndex        = "auction-id"
 	AuctionCreatedCeiling      = "ceiling"
 	// hardware
-	// AuctionCreatedGpu     = "gpu"
-	// AuctionCreatedCpuArch = "cpu-arch"
-	// AuctionCreatedMemMb   = "mem-mb"
-	// AuctionCreatedStorage = "storage"
+	AuctionCreatedGpus     = "gpus"
+	AuctionCreatedCpuArch  = "cpu-arch"
+	AuctionCreatedCpuCores = "cpu-cores"
+	AuctionCreatedMemMb    = "mem-mb"
+	AuctionCreatedStorage  = "storage-gb"
 )

 const (
--- a/x/colinearcore/types/message_new_auction.go
+++ b/x/colinearcore/types/message_new_auction.go
@ -9,15 +9,29 @@ const TypeMsgNewAuction = "new_auction"

 var _ sdk.Msg = &MsgNewAuction{}

-func NewMsgNewAuction(creator string, name string, description string, ceiling string, denom string, leaseEnd uint64, vProviders []string) *MsgNewAuction {
+func NewMsgNewAuction(
+	// auction params
+	creator string, name string, description string, ceiling string, denom string, leaseEnd uint64, vProviders []string,
+	// hardware specs
+	gpus []string, cpuCores uint64, cpuArch CpuArchitecture, memMb uint64, storageGb uint64,
+) *MsgNewAuction {
 	return &MsgNewAuction{
-		Creator:           creator,
+		Creator: creator,
+
+		// creation params
 		Name:              name,
 		Description:       description,
 		Ceiling:           ceiling,
 		Denom:             denom,
 		LeaseEnd:          leaseEnd,
 		VerifiedProviders: vProviders,
+
+		// hardware
+		Gpus:      gpus,
+		CpuCores:  cpuCores,
+		CpuArch:   cpuArch,
+		MemMb:     memMb,
+		StorageGb: storageGb,
 	}
 }

--- a/x/colinearcore/types/params.go
+++ b/x/colinearcore/types/params.go
@ -14,7 +14,26 @@ func ParamKeyTable() paramtypes.KeyTable {

 // NewParams creates a new Params instance
 func NewParams() Params {
-	return Params{}
+	// return Params{}
+
+	// temp fix
+
+	return Params{
+		GpuModels: map[string]uint32{
+			"gtx-1050-ti": 0,
+			"gtx-1650-ti": 0,
+		},
+		AuctionTime:             10,
+		ProviderMinLockedUClr:   500_000_000,
+		ProviderLockedSlashUClr: 100_000_000,
+		AuctionGas:              10,
+		MinLeasePeriod:          3_600,     // 1 hour
+		MaxLeasePeriod:          8_035_200, // 3 months
+		MaxVerifiedProviders:    1000,
+		ProviderAuditFrequency:  400,
+		ProviderAuditLength:     4,
+		AllowedAuctionDenoms:    []string{"uclr", "uusdc"},
+	}
 }

 // DefaultParams returns a default set of parameters
--- a/x/colinearcore/types/tx.pb.go
+++ b/x/colinearcore/types/tx.pb.go
@ -37,6 +37,12 @@ type MsgNewAuction struct {
 	// verified providers just specifies who's allowed to bid on the lease auction.
 	// STORED IN MEMORY. DOES NOT GET WRITTEN TO CHAIN STATE.
 	VerifiedProviders []string `protobuf:"bytes,7,rep,name=verifiedProviders,proto3" json:"verifiedProviders,omitempty"`
+	// hardware specs (mandatory)
+	Gpus      []string        `protobuf:"bytes,8,rep,name=gpus,proto3" json:"gpus,omitempty"`
+	CpuCores  uint64          `protobuf:"varint,9,opt,name=cpuCores,proto3" json:"cpuCores,omitempty"`
+	CpuArch   CpuArchitecture `protobuf:"varint,10,opt,name=cpuArch,proto3,enum=colinear.colinearcore.CpuArchitecture" json:"cpuArch,omitempty"`
+	MemMb     uint64          `protobuf:"varint,11,opt,name=memMb,proto3" json:"memMb,omitempty"`
+	StorageGb uint64          `protobuf:"varint,12,opt,name=storageGb,proto3" json:"storageGb,omitempty"`
 }

 func (m *MsgNewAuction) Reset()         { *m = MsgNewAuction{} }
@ -121,6 +127,41 @@ func (m *MsgNewAuction) GetVerifiedProviders() []string {
 	return nil
 }

+func (m *MsgNewAuction) GetGpus() []string {
+	if m != nil {
+		return m.Gpus
+	}
+	return nil
+}
+
+func (m *MsgNewAuction) GetCpuCores() uint64 {
+	if m != nil {
+		return m.CpuCores
+	}
+	return 0
+}
+
+func (m *MsgNewAuction) GetCpuArch() CpuArchitecture {
+	if m != nil {
+		return m.CpuArch
+	}
+	return CpuArchitecture_ANY
+}
+
+func (m *MsgNewAuction) GetMemMb() uint64 {
+	if m != nil {
+		return m.MemMb
+	}
+	return 0
+}
+
+func (m *MsgNewAuction) GetStorageGb() uint64 {
+	if m != nil {
+		return m.StorageGb
+	}
+	return 0
+}
+
 type MsgNewAuctionResponse struct {
 	AuctionId string `protobuf:"bytes,1,opt,name=auctionId,proto3" json:"auctionId,omitempty"`
 }
@ -623,39 +664,45 @@ func init() {
 func init() { proto.RegisterFile("colinearcore/tx.proto", fileDescriptor_0c3854a2a9bba3b4) }

 var fileDescriptor_0c3854a2a9bba3b4 = []byte{
-	// 512 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x51, 0x8b, 0xd3, 0x40,
-	0x10, 0xc7, 0x9b, 0xb6, 0xd7, 0x33, 0x73, 0xe7, 0xc1, 0xad, 0x77, 0x35, 0x46, 0x0d, 0x21, 0x2a,
-	0x04, 0xbc, 0x6b, 0x45, 0x11, 0x5f, 0xbd, 0x8a, 0x8a, 0x60, 0x45, 0x8a, 0xbe, 0x08, 0xc2, 0xc5,
-	0xec, 0x1a, 0x16, 0xd3, 0xdd, 0xb2, 0x9b, 0x9e, 0xf5, 0x5b, 0xf8, 0xb1, 0x7c, 0x3c, 0xdf, 0xf4,
-	0x4d, 0xda, 0x2f, 0x22, 0x6e, 0x92, 0x4d, 0x72, 0xb5, 0x69, 0xe1, 0xde, 0x3a, 0x33, 0xff, 0xf9,
-	0x4d, 0x76, 0xe7, 0xdf, 0x85, 0xc3, 0x90, 0xc7, 0x94, 0x91, 0x40, 0x84, 0x5c, 0x90, 0x7e, 0x32,
-	0xeb, 0x4d, 0x04, 0x4f, 0x38, 0xd2, 0xe9, 0x5e, 0xb9, 0xee, 0xfd, 0x36, 0xe0, 0xea, 0x50, 0x46,
-	0x6f, 0xc8, 0xd7, 0x93, 0x69, 0x98, 0x50, 0xce, 0x90, 0x05, 0xdb, 0xa1, 0x20, 0x41, 0xc2, 0x85,
-	0x65, 0xb8, 0x86, 0x6f, 0x8e, 0xf2, 0x10, 0x21, 0x68, 0xb3, 0x60, 0x4c, 0xac, 0xa6, 0x4a, 0xab,
-	0xdf, 0xc8, 0x85, 0x1d, 0x4c, 0x64, 0x28, 0xe8, 0xe4, 0x5f, 0xb3, 0xd5, 0x52, 0xa5, 0x72, 0x4a,
-	0xf1, 0x08, 0x8d, 0x29, 0x8b, 0xac, 0x76, 0xc6, 0x4b, 0x43, 0x74, 0x00, 0x5b, 0x98, 0x30, 0x3e,
-	0xb6, 0xb6, 0x54, 0x3e, 0x0d, 0x90, 0x0d, 0x57, 0x62, 0x12, 0x48, 0xf2, 0x9c, 0x61, 0xab, 0xe3,
-	0x1a, 0x7e, 0x7b, 0xa4, 0x63, 0x74, 0x04, 0xfb, 0x67, 0x44, 0xd0, 0xcf, 0x94, 0xe0, 0xb7, 0x82,
-	0x9f, 0x51, 0x4c, 0x84, 0xb4, 0xb6, 0xdd, 0x96, 0x6f, 0x8e, 0x96, 0x0b, 0xde, 0x63, 0x38, 0xac,
-	0x1c, 0x6d, 0x44, 0xe4, 0x84, 0x33, 0x49, 0xd0, 0x2d, 0x30, 0x83, 0x34, 0xf5, 0x0a, 0x67, 0x87,
-	0x2c, 0x12, 0x5e, 0x00, 0x66, 0xda, 0x36, 0xa0, 0xb8, 0xe6, 0x36, 0x3c, 0xd8, 0xcd, 0x7b, 0x18,
-	0x26, 0xb3, 0xec, 0x56, 0x2a, 0x39, 0xd4, 0x85, 0x4e, 0x30, 0xe6, 0x53, 0x96, 0x64, 0x17, 0x93,
-	0x45, 0xde, 0x35, 0xd8, 0xd7, 0x23, 0xf2, 0xaf, 0xf2, 0x9e, 0xc2, 0xee, 0x50, 0x46, 0xaf, 0x79,
-	0xf8, 0xe5, 0xc5, 0x94, 0x61, 0x59, 0x33, 0xba, 0xc0, 0x36, 0x2b, 0xd8, 0x2e, 0x1c, 0x94, 0x09,
-	0x9a, 0x3c, 0x80, 0xbd, 0xa1, 0x8c, 0xde, 0xb3, 0xf8, 0x12, 0x6c, 0x0b, 0xba, 0x55, 0x86, 0xa6,
-	0x1f, 0xab, 0xc3, 0xa4, 0x95, 0x93, 0x38, 0x5e, 0x33, 0xc0, 0xbb, 0x09, 0x37, 0x96, 0xe4, 0x9a,
-	0xf5, 0x52, 0xb9, 0xf1, 0x59, 0x1c, 0xd0, 0xf1, 0xba, 0x0f, 0xad, 0x2c, 0xb1, 0x79, 0x71, 0x89,
-	0xd7, 0xd5, 0xee, 0x0b, 0x50, 0x3e, 0xe1, 0xe1, 0xcf, 0x36, 0xb4, 0x86, 0x32, 0x42, 0xa7, 0x00,
-	0x25, 0xd3, 0xdf, 0xed, 0xfd, 0xf7, 0xef, 0xd1, 0xab, 0xf8, 0xc7, 0x3e, 0xda, 0x44, 0xa5, 0x5d,
-	0xf6, 0x0e, 0x3a, 0x99, 0x89, 0xdc, 0xda, 0xbe, 0x01, 0xc5, 0xb6, 0xbf, 0x4e, 0xa1, 0xa9, 0x1f,
-	0xc1, 0x2c, 0x2c, 0x72, 0x67, 0x75, 0x9b, 0x16, 0xd9, 0xf7, 0x37, 0x10, 0x69, 0x7c, 0x08, 0x3b,
-	0x65, 0x9f, 0xdc, 0x5b, 0xdd, 0x5b, 0x92, 0xd9, 0xc7, 0x1b, 0xc9, 0xf4, 0x90, 0x18, 0xf6, 0x2e,
-	0xd8, 0xc5, 0x5f, 0x07, 0xc8, 0x95, 0xf6, 0x83, 0x4d, 0x95, 0x7a, 0xda, 0x29, 0x40, 0xc9, 0x50,
-	0x35, 0x9b, 0x2e, 0x54, 0x75, 0x9b, 0x5e, 0xf6, 0xd4, 0xe0, 0xc9, 0x8f, 0xb9, 0x63, 0x9c, 0xcf,
-	0x1d, 0xe3, 0xcf, 0xdc, 0x31, 0xbe, 0x2f, 0x9c, 0xc6, 0xf9, 0xc2, 0x69, 0xfc, 0x5a, 0x38, 0x8d,
-	0x0f, 0xb7, 0xf3, 0xee, 0xfe, 0xac, 0x5f, 0x7d, 0x97, 0xbf, 0x4d, 0x88, 0xfc, 0xd4, 0x51, 0x6f,
-	0xf3, 0xa3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x40, 0xff, 0x13, 0xb4, 0x05, 0x00, 0x00,
+	// 601 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x5f, 0x4f, 0xd4, 0x4e,
+	0x14, 0xa5, 0xcb, 0xb2, 0xd0, 0x0b, 0x3f, 0x12, 0xe6, 0x07, 0x38, 0x16, 0x6d, 0x9a, 0xfa, 0x27,
+	0x4d, 0x84, 0xc5, 0x60, 0x8c, 0xaf, 0xb0, 0x44, 0x89, 0x89, 0x6b, 0xcc, 0x46, 0x5f, 0x4c, 0x4c,
+	0x28, 0xed, 0x58, 0x26, 0xb6, 0x9d, 0x66, 0xa6, 0x05, 0xfc, 0x16, 0x7e, 0x2c, 0x1f, 0xf1, 0xcd,
+	0x47, 0xc3, 0x7e, 0x10, 0xcd, 0x4e, 0xdb, 0x69, 0xcb, 0xba, 0x7f, 0x12, 0xdf, 0x7a, 0xef, 0x3d,
+	0xe7, 0xdc, 0x69, 0xcf, 0x69, 0x06, 0xb6, 0x3c, 0x16, 0xd2, 0x98, 0xb8, 0xdc, 0x63, 0x9c, 0xec,
+	0xa7, 0x57, 0xdd, 0x84, 0xb3, 0x94, 0x21, 0xd5, 0xee, 0xd6, 0xe7, 0xc6, 0x4e, 0x03, 0x7d, 0xee,
+	0x72, 0xff, 0xd2, 0xe5, 0x24, 0xe7, 0xd8, 0xbf, 0x5b, 0xf0, 0x5f, 0x5f, 0x04, 0x6f, 0xc9, 0xe5,
+	0x51, 0xe6, 0xa5, 0x94, 0xc5, 0x08, 0xc3, 0xb2, 0xc7, 0x89, 0x9b, 0x32, 0x8e, 0x35, 0x4b, 0x73,
+	0xf4, 0x41, 0x59, 0x22, 0x04, 0xed, 0xd8, 0x8d, 0x08, 0x6e, 0xc9, 0xb6, 0x7c, 0x46, 0x16, 0xac,
+	0xfa, 0x44, 0x78, 0x9c, 0x26, 0x23, 0x32, 0x5e, 0x94, 0xa3, 0x7a, 0x4b, 0xea, 0x11, 0x1a, 0xd2,
+	0x38, 0xc0, 0xed, 0x42, 0x2f, 0x2f, 0xd1, 0x26, 0x2c, 0xf9, 0x24, 0x66, 0x11, 0x5e, 0x92, 0xfd,
+	0xbc, 0x40, 0x06, 0xac, 0x84, 0xc4, 0x15, 0xe4, 0x65, 0xec, 0xe3, 0x8e, 0xa5, 0x39, 0xed, 0x81,
+	0xaa, 0xd1, 0x2e, 0x6c, 0x5c, 0x10, 0x4e, 0x3f, 0x53, 0xe2, 0xbf, 0xe3, 0xec, 0x82, 0xfa, 0x84,
+	0x0b, 0xbc, 0x6c, 0x2d, 0x3a, 0xfa, 0x60, 0x7c, 0x30, 0x3a, 0x6f, 0x90, 0x64, 0x02, 0xaf, 0x48,
+	0x80, 0x7c, 0x1e, 0xa9, 0x7b, 0x49, 0x76, 0xcc, 0x38, 0x11, 0x58, 0xcf, 0xd5, 0xcb, 0x1a, 0x1d,
+	0xc2, 0xb2, 0x97, 0x64, 0x47, 0xdc, 0x3b, 0xc7, 0x60, 0x69, 0xce, 0xfa, 0xc1, 0xe3, 0xee, 0x5f,
+	0xbf, 0x68, 0xf7, 0x38, 0x47, 0xd1, 0x94, 0x78, 0x69, 0xc6, 0xc9, 0xa0, 0xa4, 0x8d, 0xde, 0x28,
+	0x22, 0x51, 0xff, 0x0c, 0xaf, 0x4a, 0xe9, 0xbc, 0x40, 0xf7, 0x40, 0x17, 0x29, 0xe3, 0x6e, 0x40,
+	0x4e, 0xce, 0xf0, 0x9a, 0x9c, 0x54, 0x0d, 0xfb, 0x39, 0x6c, 0x35, 0x0c, 0x18, 0x10, 0x91, 0xb0,
+	0x58, 0x90, 0x11, 0xcd, 0xcd, 0x5b, 0xaf, 0xfd, 0xc2, 0x8a, 0xaa, 0x61, 0xbb, 0xa0, 0xe7, 0xb4,
+	0x1e, 0xf5, 0xa7, 0x78, 0x66, 0xc3, 0x5a, 0xc9, 0x89, 0x7d, 0x72, 0x55, 0x78, 0xd7, 0xe8, 0xa1,
+	0x6d, 0xe8, 0xb8, 0x11, 0xcb, 0xe2, 0xb4, 0xb0, 0xaf, 0xa8, 0xec, 0xff, 0x61, 0x43, 0xad, 0x28,
+	0x4f, 0x65, 0x1f, 0xc2, 0x5a, 0x5f, 0x04, 0x6f, 0x98, 0xf7, 0xe5, 0x55, 0x16, 0xfb, 0x62, 0xca,
+	0xea, 0x4a, 0xb6, 0xd5, 0x90, 0xdd, 0x86, 0xcd, 0xba, 0x82, 0x52, 0xee, 0xc1, 0x7a, 0x5f, 0x04,
+	0x1f, 0xe2, 0xf0, 0x1f, 0xb4, 0x31, 0x6c, 0x37, 0x35, 0x94, 0xfa, 0x9e, 0x7c, 0x99, 0x7c, 0x72,
+	0x14, 0x86, 0x33, 0x16, 0xd8, 0x3b, 0x70, 0x77, 0x0c, 0xae, 0xb4, 0x4e, 0xe4, 0x3f, 0x73, 0x1c,
+	0xba, 0x34, 0x9a, 0x75, 0xd0, 0x86, 0x89, 0xad, 0xdb, 0x26, 0xde, 0x91, 0xde, 0x57, 0x42, 0xe5,
+	0x86, 0x83, 0x1f, 0x6d, 0x58, 0xec, 0x8b, 0x00, 0x9d, 0x02, 0xd4, 0x7e, 0xcd, 0x87, 0x13, 0xf2,
+	0xd8, 0xc8, 0x8f, 0xb1, 0x3b, 0x0f, 0x4a, 0xa5, 0xec, 0x3d, 0x74, 0x8a, 0x10, 0x59, 0x53, 0x79,
+	0x3d, 0xea, 0x1b, 0xce, 0x2c, 0x84, 0x52, 0xfd, 0x04, 0x7a, 0x15, 0x91, 0x07, 0x93, 0x69, 0x0a,
+	0x64, 0x3c, 0x99, 0x03, 0xa4, 0xe4, 0x3d, 0x58, 0xad, 0xe7, 0xe4, 0xd1, 0x64, 0x6e, 0x0d, 0x66,
+	0xec, 0xcd, 0x05, 0x53, 0x4b, 0x42, 0x58, 0xbf, 0x15, 0x17, 0x67, 0x96, 0x40, 0x89, 0x34, 0x9e,
+	0xce, 0x8b, 0x54, 0xdb, 0x4e, 0x01, 0x6a, 0x81, 0x9a, 0xe2, 0x74, 0x85, 0x9a, 0xe6, 0xf4, 0x78,
+	0xa6, 0x7a, 0x2f, 0xbe, 0xdf, 0x98, 0xda, 0xf5, 0x8d, 0xa9, 0xfd, 0xba, 0x31, 0xb5, 0x6f, 0x43,
+	0x73, 0xe1, 0x7a, 0x68, 0x2e, 0xfc, 0x1c, 0x9a, 0x0b, 0x1f, 0xef, 0x97, 0xec, 0xfd, 0xab, 0xfd,
+	0xe6, 0xd5, 0xf2, 0x35, 0x21, 0xe2, 0xac, 0x23, 0xaf, 0x8a, 0x67, 0x7f, 0x02, 0x00, 0x00, 0xff,
+	0xff, 0x44, 0xed, 0x86, 0xa7, 0x77, 0x06, 0x00, 0x00,
 }

 // Reference imports to suppress errors if they are not otherwise used.
@ -938,6 +985,35 @@ func (m *MsgNewAuction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.StorageGb != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.StorageGb))
+		i--
+		dAtA[i] = 0x60
+	}
+	if m.MemMb != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.MemMb))
+		i--
+		dAtA[i] = 0x58
+	}
+	if m.CpuArch != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.CpuArch))
+		i--
+		dAtA[i] = 0x50
+	}
+	if m.CpuCores != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.CpuCores))
+		i--
+		dAtA[i] = 0x48
+	}
+	if len(m.Gpus) > 0 {
+		for iNdEx := len(m.Gpus) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Gpus[iNdEx])
+			copy(dAtA[i:], m.Gpus[iNdEx])
+			i = encodeVarintTx(dAtA, i, uint64(len(m.Gpus[iNdEx])))
+			i--
+			dAtA[i] = 0x42
+		}
+	}
 	if len(m.VerifiedProviders) > 0 {
 		for iNdEx := len(m.VerifiedProviders) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.VerifiedProviders[iNdEx])
@ -1366,6 +1442,24 @@ func (m *MsgNewAuction) Size() (n int) {
 			n += 1 + l + sovTx(uint64(l))
 		}
 	}
+	if len(m.Gpus) > 0 {
+		for _, s := range m.Gpus {
+			l = len(s)
+			n += 1 + l + sovTx(uint64(l))
+		}
+	}
+	if m.CpuCores != 0 {
+		n += 1 + sovTx(uint64(m.CpuCores))
+	}
+	if m.CpuArch != 0 {
+		n += 1 + sovTx(uint64(m.CpuArch))
+	}
+	if m.MemMb != 0 {
+		n += 1 + sovTx(uint64(m.MemMb))
+	}
+	if m.StorageGb != 0 {
+		n += 1 + sovTx(uint64(m.StorageGb))
+	}
 	return n
 }

@ -1758,6 +1852,114 @@ func (m *MsgNewAuction) Unmarshal(dAtA []byte) error {
 			}
 			m.VerifiedProviders = append(m.VerifiedProviders, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Gpus", 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.Gpus = append(m.Gpus, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CpuCores", wireType)
+			}
+			m.CpuCores = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CpuCores |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CpuArch", wireType)
+			}
+			m.CpuArch = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CpuArch |= CpuArchitecture(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MemMb", wireType)
+			}
+			m.MemMb = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MemMb |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 12:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StorageGb", wireType)
+			}
+			m.StorageGb = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StorageGb |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTx(dAtA[iNdEx:])
Author	SHA1	Message	Date
michael	2ea722c81c	fixes + test hw edge cases	2022-09-23 00:16:42 +00:00
michael	fba158d4d1	CLI tests, updates, fixes (reflect hw options)	2022-09-22 23:59:03 +00:00
michael	e57473e2d2	add hardware args to cli lease creation [UNTESTED]	2022-09-22 23:43:15 +00:00
michael	f25f798443	new auction tx & event emission includes hw specs [UNTESTED]	2022-09-22 23:18:08 +00:00
michael	98c082693d	hardware specs mandatory in auction creation msg	2022-09-22 23:01:31 +00:00
michael	0b040b4334	cpu cores field	2022-09-22 22:40:51 +00:00
michael	2fbd031988	temp fix for params init, finish later	2022-09-22 21:48:07 +00:00
michael	8b201e32de	populate dev config params genesis state	2022-09-22 00:49:52 +00:00