diff --git a/go/inventory/v1/cluster.pb.go b/go/inventory/v1/cluster.pb.go
index 8f94715a..36e493af 100644
--- a/go/inventory/v1/cluster.pb.go
+++ b/go/inventory/v1/cluster.pb.go
@@ -24,8 +24,8 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type Cluster struct {
-	Nodes   Nodes            `protobuf:"bytes,1,rep,name=nodes,proto3,castrepeated=Nodes" json:"nodes" yaml:"nodes"`
-	Storage []ClusterStorage `protobuf:"bytes,2,rep,name=storage,proto3,casttype=ClusterStorage" json:"storage" yaml:"storage"`
+	Nodes   []Node    `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes" yaml:"nodes"`
+	Storage []Storage `protobuf:"bytes,2,rep,name=storage,proto3" json:"storage" yaml:"storage"`
 }
 
 func (m *Cluster) Reset()         { *m = Cluster{} }
@@ -61,14 +61,14 @@ func (m *Cluster) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Cluster proto.InternalMessageInfo
 
-func (m *Cluster) GetNodes() Nodes {
+func (m *Cluster) GetNodes() []Node {
 	if m != nil {
 		return m.Nodes
 	}
 	return nil
 }
 
-func (m *Cluster) GetStorage() []ClusterStorage {
+func (m *Cluster) GetStorage() []Storage {
 	if m != nil {
 		return m.Storage
 	}
@@ -82,27 +82,26 @@ func init() {
 func init() { proto.RegisterFile("akash/inventory/v1/cluster.proto", fileDescriptor_205585ebfe7f68ce) }
 
 var fileDescriptor_205585ebfe7f68ce = []byte{
-	// 312 bytes of a gzipped FileDescriptorProto
+	// 299 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x48, 0xcc, 0x4e, 0x2c,
 	0xce, 0xd0, 0xcf, 0xcc, 0x2b, 0x4b, 0xcd, 0x2b, 0xc9, 0x2f, 0xaa, 0xd4, 0x2f, 0x33, 0xd4, 0x4f,
 	0xce, 0x29, 0x2d, 0x2e, 0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x02, 0xab,
 	0xd0, 0x83, 0xab, 0xd0, 0x2b, 0x33, 0x94, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x4b, 0xeb, 0x83,
 	0x58, 0x10, 0x95, 0x52, 0xb2, 0x58, 0xcc, 0xca, 0xcb, 0x4f, 0x49, 0x85, 0x4a, 0xab, 0x62, 0x91,
 	0x2e, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0x2d, 0x48, 0xcc, 0x84, 0xda, 0x27, 0x85, 0xcd,
-	0x45, 0xc5, 0x25, 0xf9, 0x45, 0x89, 0xe9, 0x50, 0x83, 0x94, 0x9e, 0x33, 0x72, 0xb1, 0x3b, 0x43,
-	0xdc, 0x28, 0x14, 0xcf, 0xc5, 0x0a, 0xb2, 0xa2, 0x58, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x48,
-	0x42, 0x0f, 0xd3, 0xb5, 0x7a, 0x7e, 0xf9, 0x29, 0xa9, 0x4e, 0xfa, 0x27, 0xee, 0xc9, 0x33, 0x3c,
+	0x45, 0xc5, 0x25, 0xf9, 0x45, 0x89, 0xe9, 0x50, 0x83, 0x94, 0xce, 0x30, 0x72, 0xb1, 0x3b, 0x43,
+	0xdc, 0x28, 0x14, 0xc6, 0xc5, 0x0a, 0xb2, 0xa2, 0x58, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x48,
+	0x42, 0x0f, 0xd3, 0xb5, 0x7a, 0x7e, 0xf9, 0x29, 0xa9, 0x4e, 0x6a, 0x27, 0xee, 0xc9, 0x33, 0x3c,
 	0xba, 0x27, 0xcf, 0x0a, 0xe2, 0x15, 0xbf, 0xba, 0x27, 0x0f, 0xd1, 0xf7, 0xe9, 0x9e, 0x3c, 0x4f,
-	0x65, 0x62, 0x6e, 0x8e, 0x95, 0x12, 0x98, 0xab, 0xb4, 0xea, 0x3e, 0x54, 0x45, 0x10, 0x44, 0x5e,
-	0xa8, 0x94, 0x8b, 0x1d, 0x6a, 0xbb, 0x04, 0x13, 0xd8, 0x0a, 0x69, 0x6c, 0x56, 0x04, 0x43, 0x94,
-	0x38, 0xd9, 0x41, 0x6d, 0x61, 0x87, 0x0a, 0xbc, 0xba, 0x27, 0x0f, 0xd3, 0xfe, 0xe9, 0x9e, 0x3c,
-	0x1f, 0xc4, 0x26, 0xa8, 0x80, 0xd2, 0xaf, 0x7b, 0xf2, 0x7c, 0x50, 0x7f, 0x40, 0x95, 0x07, 0xc1,
-	0x14, 0x5b, 0xb1, 0xbc, 0x58, 0x20, 0xcf, 0xe0, 0xe4, 0x73, 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, 0x46, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa,
-	0x60, 0xf7, 0xe8, 0xe6, 0xa5, 0x96, 0x94, 0xe7, 0x17, 0x65, 0x43, 0x79, 0x89, 0x05, 0x99, 0xfa,
-	0xe9, 0xf9, 0x28, 0xa1, 0x98, 0xc4, 0x06, 0x0e, 0x3e, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0x6e, 0x7d, 0x4d, 0xbd, 0xf4, 0x01, 0x00, 0x00,
+	0x65, 0x62, 0x6e, 0x8e, 0x95, 0x12, 0x98, 0xab, 0x14, 0x04, 0x11, 0x16, 0x4a, 0xe6, 0x62, 0x87,
+	0x5a, 0x2a, 0xc1, 0x04, 0x36, 0x59, 0x1a, 0x9b, 0xc9, 0xc1, 0x10, 0x25, 0x4e, 0x3a, 0x50, 0xc3,
+	0xd9, 0xa1, 0x02, 0xaf, 0xee, 0xc9, 0xc3, 0xb4, 0x7f, 0xba, 0x27, 0xcf, 0x07, 0xb1, 0x00, 0x2a,
+	0xa0, 0x14, 0x04, 0x93, 0xb2, 0x62, 0x79, 0xb1, 0x40, 0x9e, 0xc1, 0xc9, 0xe7, 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, 0x8c, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92,
+	0xf3, 0x73, 0xf5, 0xc1, 0xb6, 0xeb, 0xe6, 0xa5, 0x96, 0x94, 0xe7, 0x17, 0x65, 0x43, 0x79, 0x89,
+	0x05, 0x99, 0xfa, 0xe9, 0xf9, 0x28, 0x41, 0x95, 0xc4, 0x06, 0x0e, 0x23, 0x63, 0x40, 0x00, 0x00,
+	0x00, 0xff, 0xff, 0x66, 0x15, 0x3e, 0x60, 0xd9, 0x01, 0x00, 0x00,
 }
 
 func (m *Cluster) Marshal() (dAtA []byte, err error) {
@@ -286,7 +285,7 @@ func (m *Cluster) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Storage = append(m.Storage, ClusterStorage{})
+			m.Storage = append(m.Storage, Storage{})
 			if err := m.Storage[len(m.Storage)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/go/inventory/v1/cpu.pb.go b/go/inventory/v1/cpu.pb.go
index d9289cef..9cd33306 100644
--- a/go/inventory/v1/cpu.pb.go
+++ b/go/inventory/v1/cpu.pb.go
@@ -6,7 +6,7 @@ package v1
 import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -21,7 +21,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type CPUInfo struct {
 	ID     string `protobuf:"bytes,1,opt,name=id,proto3" json:"id" yaml:"id"`
@@ -151,34 +151,34 @@ func init() {
 func init() { proto.RegisterFile("akash/inventory/v1/cpu.proto", fileDescriptor_ed2b8a0bd798e5a3) }
 
 var fileDescriptor_ed2b8a0bd798e5a3 = []byte{
-	// 418 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x41, 0x8b, 0xd3, 0x40,
-	0x14, 0xc7, 0x3b, 0x69, 0xb7, 0xee, 0x4e, 0x5d, 0x84, 0xe0, 0x21, 0xae, 0x92, 0x57, 0x06, 0x16,
-	0x2a, 0x62, 0xc2, 0xd6, 0x8b, 0x08, 0x5e, 0xba, 0x5e, 0x16, 0x14, 0x6a, 0x60, 0x3d, 0x78, 0xcb,
-	0x36, 0x69, 0x77, 0xd8, 0xed, 0x4c, 0x9d, 0x26, 0x91, 0x7e, 0x0b, 0x3f, 0x93, 0x27, 0x8f, 0x7b,
-	0xf4, 0x34, 0xc8, 0xf4, 0x16, 0x3c, 0xe5, 0x13, 0x48, 0xde, 0x8c, 0x45, 0xd9, 0xde, 0xde, 0xfb,
-	0xff, 0xdf, 0x7f, 0x7e, 0xe4, 0xe5, 0xd1, 0x67, 0xe9, 0x4d, 0xba, 0xbe, 0x8e, 0xb9, 0xa8, 0x72,
-	0x51, 0x48, 0xb5, 0x89, 0xab, 0xb3, 0x78, 0xb6, 0x2a, 0xa3, 0x95, 0x92, 0x85, 0xf4, 0x7d, 0x74,
-	0xa3, 0x9d, 0x1b, 0x55, 0x67, 0x27, 0x8f, 0x17, 0x72, 0x21, 0xd1, 0x8e, 0xdb, 0xca, 0x4e, 0x9e,
-	0x9c, 0xee, 0x79, 0x47, 0xe5, 0x6b, 0x59, 0xaa, 0x59, 0xbe, 0x4a, 0xb9, 0xb2, 0x63, 0xec, 0x37,
-	0xa1, 0x0f, 0xce, 0xa7, 0x97, 0x17, 0x62, 0x2e, 0xfd, 0xe7, 0xd4, 0xe3, 0x59, 0x40, 0x86, 0x64,
-	0x74, 0x34, 0x79, 0x62, 0x34, 0x78, 0x17, 0xef, 0x6a, 0x0d, 0x1e, 0xcf, 0x1a, 0x0d, 0x47, 0x9b,
-	0x74, 0x79, 0xfb, 0x86, 0xf1, 0x8c, 0x25, 0x1e, 0xcf, 0xfc, 0xb7, 0xb4, 0x5f, 0xe5, 0x22, 0x93,
-	0x2a, 0xf0, 0x70, 0xfc, 0xd4, 0x68, 0xe8, 0x7f, 0x42, 0xa5, 0xd6, 0xe0, 0xbc, 0x46, 0xc3, 0xb1,
-	0x8d, 0xd9, 0x9e, 0x25, 0xce, 0xf0, 0x5f, 0xd3, 0x83, 0xa5, 0xcc, 0xf2, 0xdb, 0xa0, 0x8b, 0x69,
-	0x66, 0x34, 0x1c, 0x7c, 0x68, 0x85, 0x5a, 0x83, 0x75, 0x1a, 0x0d, 0x0f, 0x6d, 0x16, 0x5b, 0x96,
-	0x58, 0x19, 0xc1, 0x33, 0xa9, 0xf2, 0x75, 0xd0, 0x1b, 0x92, 0xd1, 0xb1, 0x03, 0xa3, 0x82, 0x60,
-	0xac, 0xfe, 0x01, 0x63, 0xdf, 0x82, 0x6d, 0xf1, 0x9d, 0xd0, 0xee, 0xf9, 0xf4, 0xd2, 0xe7, 0xf4,
-	0xf0, 0x4b, 0x99, 0x8a, 0x82, 0x17, 0x1b, 0xfc, 0xe0, 0xc1, 0x78, 0x18, 0xdd, 0x5f, 0x6d, 0x94,
-	0xb8, 0x85, 0x4d, 0x53, 0xae, 0x26, 0x2f, 0x8c, 0x86, 0xc3, 0x8f, 0x2e, 0x55, 0x6b, 0xd8, 0xbd,
-	0xd0, 0x68, 0x78, 0x64, 0x71, 0x7f, 0x15, 0x96, 0xec, 0x4c, 0x7f, 0x4a, 0x7b, 0x5c, 0xcc, 0x65,
-	0xe0, 0x0d, 0xbb, 0xa3, 0xc1, 0xf8, 0xe9, 0x3e, 0x8c, 0xfb, 0x01, 0x13, 0x30, 0x1a, 0x7a, 0x6d,
-	0x55, 0x6b, 0xc0, 0x50, 0xa3, 0x61, 0xe0, 0x16, 0x2f, 0xe6, 0x92, 0x25, 0x28, 0x4e, 0xde, 0xff,
-	0x30, 0x21, 0xb9, 0x33, 0x21, 0xf9, 0x65, 0x42, 0xf2, 0x6d, 0x1b, 0x76, 0xee, 0xb6, 0x61, 0xe7,
-	0xe7, 0x36, 0xec, 0x7c, 0x1e, 0x2f, 0x78, 0x71, 0x5d, 0x5e, 0x45, 0x33, 0xb9, 0x8c, 0x91, 0xf3,
-	0x52, 0xe4, 0xc5, 0x57, 0xa9, 0x6e, 0x5c, 0x97, 0xae, 0x78, 0xbc, 0x90, 0xff, 0x1d, 0xc5, 0x55,
-	0x1f, 0x0f, 0xe1, 0xd5, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x23, 0x41, 0x15, 0x12, 0x79, 0x02,
-	0x00, 0x00,
+	// 422 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x31, 0x6f, 0xd3, 0x40,
+	0x14, 0xc7, 0x73, 0x4e, 0x1a, 0xda, 0x0b, 0x15, 0x92, 0xc5, 0x60, 0x0a, 0xf2, 0x8b, 0x4e, 0xaa,
+	0x14, 0x84, 0xb0, 0xd5, 0xb0, 0x20, 0x24, 0x96, 0x94, 0xa5, 0x03, 0x92, 0xb1, 0x54, 0x06, 0x36,
+	0x37, 0x76, 0xd2, 0x53, 0x9b, 0xbb, 0x70, 0x71, 0x82, 0xf2, 0x2d, 0x18, 0xf9, 0x3c, 0x4c, 0x8c,
+	0x1d, 0x99, 0x4e, 0xe8, 0xbc, 0x59, 0x4c, 0xfe, 0x04, 0xc8, 0xef, 0x8e, 0x08, 0xd4, 0x6c, 0xef,
+	0xfd, 0xff, 0xef, 0x7f, 0x3f, 0xf9, 0xf9, 0xd1, 0x67, 0xd9, 0x4d, 0xb6, 0xba, 0x8e, 0xb9, 0xd8,
+	0x14, 0xa2, 0x94, 0x6a, 0x1b, 0x6f, 0xce, 0xe2, 0xe9, 0x72, 0x1d, 0x2d, 0x95, 0x2c, 0xa5, 0xef,
+	0xa3, 0x1b, 0xed, 0xdc, 0x68, 0x73, 0x76, 0xf2, 0x78, 0x2e, 0xe7, 0x12, 0xed, 0xb8, 0xad, 0xec,
+	0xe4, 0xc9, 0xe9, 0x9e, 0x77, 0x54, 0xb1, 0x92, 0x6b, 0x35, 0x2d, 0x96, 0x19, 0x57, 0x76, 0x8c,
+	0xfd, 0x26, 0xf4, 0xc1, 0x79, 0x72, 0x79, 0x21, 0x66, 0xd2, 0x7f, 0x4e, 0x3d, 0x9e, 0x07, 0x64,
+	0x48, 0x46, 0x47, 0x93, 0x27, 0x46, 0x83, 0x77, 0xf1, 0xae, 0xd6, 0xe0, 0xf1, 0xbc, 0xd1, 0x70,
+	0xb4, 0xcd, 0x16, 0xb7, 0x6f, 0x18, 0xcf, 0x59, 0xea, 0xf1, 0xdc, 0x7f, 0x4b, 0xfb, 0x9b, 0x42,
+	0xe4, 0x52, 0x05, 0x1e, 0x8e, 0x9f, 0x1a, 0x0d, 0xfd, 0x8f, 0xa8, 0xd4, 0x1a, 0x9c, 0xd7, 0x68,
+	0x38, 0xb6, 0x31, 0xdb, 0xb3, 0xd4, 0x19, 0xfe, 0x6b, 0x7a, 0xb0, 0x90, 0x79, 0x71, 0x1b, 0x74,
+	0x31, 0xcd, 0x8c, 0x86, 0x83, 0xf7, 0xad, 0x50, 0x6b, 0xb0, 0x4e, 0xa3, 0xe1, 0xa1, 0xcd, 0x62,
+	0xcb, 0x52, 0x2b, 0x23, 0x78, 0x2a, 0x55, 0xb1, 0x0a, 0x7a, 0x43, 0x32, 0x3a, 0x76, 0x60, 0x54,
+	0x10, 0x8c, 0xd5, 0x3f, 0x60, 0xec, 0x5b, 0xb0, 0x2d, 0xbe, 0x13, 0xda, 0x3d, 0x4f, 0x2e, 0x7d,
+	0x4e, 0x0f, 0x3f, 0xaf, 0x33, 0x51, 0xf2, 0x72, 0x8b, 0x1f, 0x3c, 0x18, 0x0f, 0xa3, 0xfb, 0xab,
+	0x8d, 0x52, 0xb7, 0xb0, 0x24, 0xe3, 0x6a, 0xf2, 0xc2, 0x68, 0x38, 0xfc, 0xe0, 0x52, 0xb5, 0x86,
+	0xdd, 0x0b, 0x8d, 0x86, 0x47, 0x16, 0xf7, 0x57, 0x61, 0xe9, 0xce, 0xf4, 0x13, 0xda, 0xe3, 0x62,
+	0x26, 0x03, 0x6f, 0xd8, 0x1d, 0x0d, 0xc6, 0x4f, 0xf7, 0x61, 0xdc, 0x0f, 0x98, 0x80, 0xd1, 0xd0,
+	0x6b, 0xab, 0x5a, 0x03, 0x86, 0x1a, 0x0d, 0x03, 0xb7, 0x78, 0x31, 0x93, 0x2c, 0x45, 0x71, 0x92,
+	0xfc, 0x30, 0x21, 0xb9, 0x33, 0x21, 0xf9, 0x65, 0x42, 0xf2, 0xb5, 0x0a, 0x3b, 0xdf, 0xaa, 0xb0,
+	0x73, 0x57, 0x85, 0x9d, 0x9f, 0x55, 0xd8, 0xf9, 0x34, 0x9e, 0xf3, 0xf2, 0x7a, 0x7d, 0x15, 0x4d,
+	0xe5, 0x22, 0x46, 0xd6, 0x4b, 0x51, 0x94, 0x5f, 0xa4, 0xba, 0x71, 0x5d, 0xb6, 0xe4, 0xf1, 0x5c,
+	0xfe, 0x77, 0x18, 0x57, 0x7d, 0x3c, 0x86, 0x57, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x26, 0x1c,
+	0x31, 0x65, 0x7d, 0x02, 0x00, 0x00,
 }
 
 func (m *CPUInfo) Marshal() (dAtA []byte, err error) {
diff --git a/go/inventory/v1/gpu.pb.go b/go/inventory/v1/gpu.pb.go
index ba652d56..e87d00a5 100644
--- a/go/inventory/v1/gpu.pb.go
+++ b/go/inventory/v1/gpu.pb.go
@@ -6,7 +6,7 @@ package v1
 import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -21,7 +21,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type GPUInfo struct {
 	Vendor    string `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor" yaml:"vendor"`
@@ -159,35 +159,36 @@ func init() {
 func init() { proto.RegisterFile("akash/inventory/v1/gpu.proto", fileDescriptor_2cc01b12bd00ffcc) }
 
 var fileDescriptor_2cc01b12bd00ffcc = []byte{
-	// 448 bytes of a gzipped FileDescriptorProto
+	// 453 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0xcf, 0x6a, 0xdb, 0x40,
 	0x10, 0xc6, 0x2d, 0xdb, 0xb5, 0xe3, 0x35, 0xfd, 0x83, 0xe8, 0x41, 0xa4, 0x45, 0x63, 0x16, 0x02,
-	0x86, 0x52, 0x89, 0x38, 0xb7, 0x42, 0x2f, 0xa6, 0x10, 0x0c, 0x49, 0x71, 0x05, 0xe9, 0xa1, 0xb7,
-	0x8d, 0xbd, 0x56, 0x96, 0x44, 0xbb, 0xee, 0x46, 0x76, 0xf1, 0x5b, 0xf4, 0x99, 0x7a, 0xea, 0xa9,
-	0xe4, 0xd8, 0xd3, 0x52, 0xe4, 0x9b, 0x8e, 0x7a, 0x82, 0xb2, 0x7f, 0x2c, 0x51, 0x9a, 0xdb, 0xce,
-	0xf7, 0x9b, 0x6f, 0x06, 0xe6, 0x5b, 0xf4, 0x9a, 0xdc, 0x92, 0xfb, 0x9b, 0x98, 0xf1, 0x2d, 0xe5,
-	0xb9, 0x90, 0xbb, 0x78, 0x7b, 0x1a, 0xa7, 0xeb, 0x4d, 0xb4, 0x96, 0x22, 0x17, 0xbe, 0x6f, 0x68,
-	0x54, 0xd3, 0x68, 0x7b, 0x7a, 0xfc, 0x32, 0x15, 0xa9, 0x30, 0x38, 0xd6, 0x2f, 0xdb, 0x79, 0x7c,
-	0xf2, 0xc8, 0x1c, 0x49, 0xef, 0xc5, 0x46, 0x2e, 0xe8, 0x9a, 0x30, 0x69, 0xdb, 0xf0, 0xaf, 0x36,
-	0xea, 0x9f, 0xcf, 0xaf, 0x66, 0x7c, 0x25, 0xfc, 0xf7, 0xa8, 0xb7, 0xa5, 0x7c, 0x29, 0x64, 0xe0,
-	0x8d, 0xbc, 0xf1, 0x60, 0x7a, 0x52, 0x28, 0xe8, 0x7d, 0x36, 0x4a, 0xa9, 0xc0, 0xb1, 0x4a, 0xc1,
-	0xd3, 0x1d, 0xc9, 0xee, 0xde, 0x61, 0x5b, 0xe3, 0xc4, 0x01, 0xff, 0x0c, 0x75, 0x39, 0xc9, 0x68,
-	0xd0, 0x36, 0x66, 0x28, 0x14, 0x74, 0x3f, 0x92, 0x8c, 0x96, 0x0a, 0x8c, 0x5e, 0x29, 0x18, 0x5a,
-	0xa3, 0xae, 0x70, 0x62, 0x44, 0x7f, 0x8a, 0xfa, 0x99, 0x58, 0xd2, 0x3b, 0xb6, 0x0c, 0x3a, 0xc6,
-	0x37, 0x2e, 0x14, 0xf4, 0x2f, 0xb5, 0x34, 0xfb, 0x50, 0x2a, 0x38, 0xd0, 0x4a, 0xc1, 0x33, 0xeb,
-	0x76, 0x02, 0x4e, 0x0e, 0xc8, 0xbf, 0x40, 0x03, 0xc6, 0x73, 0x2a, 0x57, 0x64, 0x41, 0x83, 0xae,
-	0x99, 0x12, 0x15, 0x0a, 0x06, 0xb3, 0x83, 0x58, 0x2a, 0x68, 0x3a, 0x2a, 0x05, 0x2f, 0xec, 0xa4,
-	0x5a, 0xc2, 0x49, 0x83, 0xf5, 0x15, 0x32, 0x9a, 0x09, 0xb9, 0x0b, 0x9e, 0x34, 0x57, 0xb8, 0x34,
-	0x8a, 0xbe, 0x82, 0x65, 0xcd, 0x15, 0x6c, 0x8d, 0x13, 0x07, 0xf0, 0x0f, 0x0f, 0x75, 0xce, 0xe7,
-	0x57, 0x3e, 0x43, 0x47, 0x5f, 0x37, 0x84, 0xe7, 0x2c, 0xdf, 0x99, 0x73, 0x0e, 0x27, 0xa3, 0xe8,
-	0xff, 0xf0, 0xa2, 0xc4, 0x45, 0x32, 0x27, 0x4c, 0x4e, 0xdf, 0x14, 0x0a, 0x8e, 0x3e, 0x39, 0x57,
-	0xa9, 0xa0, 0x9e, 0x50, 0x29, 0x78, 0x6e, 0xd7, 0x1d, 0x14, 0x9c, 0xd4, 0xd0, 0x9f, 0xa3, 0x2e,
-	0xe3, 0x2b, 0x11, 0xb4, 0x47, 0x9d, 0xf1, 0x70, 0xf2, 0xea, 0xb1, 0x35, 0x2e, 0x62, 0x9b, 0x8a,
-	0x7e, 0xe9, 0x54, 0xb4, 0xa9, 0x49, 0x45, 0x57, 0x38, 0x31, 0xe2, 0xf4, 0xe2, 0x67, 0x11, 0x7a,
-	0x0f, 0x45, 0xe8, 0xfd, 0x29, 0x42, 0xef, 0xfb, 0x3e, 0x6c, 0x3d, 0xec, 0xc3, 0xd6, 0xef, 0x7d,
-	0xd8, 0xfa, 0x32, 0x49, 0x59, 0x7e, 0xb3, 0xb9, 0x8e, 0x16, 0x22, 0x8b, 0xcd, 0x9e, 0xb7, 0x9c,
-	0xe6, 0xdf, 0x84, 0xbc, 0x75, 0x15, 0x59, 0xb3, 0x38, 0x15, 0xff, 0x7c, 0xbb, 0xeb, 0x9e, 0xf9,
-	0x6a, 0x67, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x72, 0x70, 0x9d, 0xb3, 0xdb, 0x02, 0x00, 0x00,
+	0x86, 0x52, 0x89, 0x38, 0xb7, 0x42, 0x2f, 0xa6, 0x10, 0x0c, 0x4d, 0x51, 0x05, 0xe9, 0xa1, 0xb7,
+	0x8d, 0xbd, 0x56, 0x96, 0x44, 0xbb, 0xee, 0x46, 0x76, 0xf1, 0x5b, 0xf4, 0xd8, 0xe7, 0xe9, 0xa9,
+	0xa7, 0x92, 0x63, 0x4f, 0x4b, 0x91, 0x6f, 0x3a, 0xea, 0x09, 0xca, 0xfe, 0xb1, 0x45, 0x69, 0x6e,
+	0x3b, 0xdf, 0x6f, 0xbe, 0x19, 0x98, 0x6f, 0xd1, 0x4b, 0x72, 0x43, 0xee, 0xae, 0x63, 0xc6, 0x37,
+	0x94, 0x17, 0x42, 0x6e, 0xe3, 0xcd, 0x69, 0x9c, 0xad, 0xd6, 0xd1, 0x4a, 0x8a, 0x42, 0xf8, 0xbe,
+	0xa1, 0xd1, 0x81, 0x46, 0x9b, 0xd3, 0xe3, 0xe7, 0x99, 0xc8, 0x84, 0xc1, 0xb1, 0x7e, 0xd9, 0xce,
+	0xe3, 0x93, 0x07, 0xe6, 0x48, 0x7a, 0x27, 0xd6, 0x72, 0x4e, 0x57, 0x84, 0x49, 0xdb, 0x86, 0x7f,
+	0xb5, 0x51, 0xff, 0x3c, 0xb9, 0x9c, 0xf1, 0xa5, 0xf0, 0xdf, 0xa2, 0xde, 0x86, 0xf2, 0x85, 0x90,
+	0x81, 0x37, 0xf2, 0xc6, 0x83, 0xe9, 0x49, 0xa9, 0xa0, 0xf7, 0xc9, 0x28, 0x95, 0x02, 0xc7, 0x6a,
+	0x05, 0x8f, 0xb7, 0x24, 0xbf, 0x7d, 0x83, 0x6d, 0x8d, 0x53, 0x07, 0xfc, 0x33, 0xd4, 0xe5, 0x24,
+	0xa7, 0x41, 0xdb, 0x98, 0xa1, 0x54, 0xd0, 0xfd, 0x40, 0x72, 0x5a, 0x29, 0x30, 0x7a, 0xad, 0x60,
+	0x68, 0x8d, 0xba, 0xc2, 0xa9, 0x11, 0xfd, 0x29, 0xea, 0xe7, 0x62, 0x41, 0x6f, 0xd9, 0x22, 0xe8,
+	0x18, 0xdf, 0xb8, 0x54, 0xd0, 0xbf, 0xd0, 0xd2, 0xec, 0x5d, 0xa5, 0x60, 0x4f, 0x6b, 0x05, 0x4f,
+	0xac, 0xdb, 0x09, 0x38, 0xdd, 0x23, 0xff, 0x3d, 0x1a, 0x30, 0x5e, 0x50, 0xb9, 0x24, 0x73, 0x1a,
+	0x74, 0xcd, 0x94, 0xa8, 0x54, 0x30, 0x98, 0xed, 0xc5, 0x4a, 0x41, 0xd3, 0x51, 0x2b, 0x78, 0x66,
+	0x27, 0x1d, 0x24, 0x9c, 0x36, 0x58, 0x5f, 0x21, 0xa7, 0xb9, 0x90, 0xdb, 0xe0, 0x51, 0x73, 0x85,
+	0x0b, 0xa3, 0xe8, 0x2b, 0x58, 0xd6, 0x5c, 0xc1, 0xd6, 0x38, 0x75, 0x00, 0xff, 0xf0, 0x50, 0xe7,
+	0x3c, 0xb9, 0xf4, 0x19, 0x3a, 0xfa, 0xb2, 0x26, 0xbc, 0x60, 0xc5, 0xd6, 0x9c, 0x73, 0x38, 0x19,
+	0x45, 0xff, 0x87, 0x17, 0xa5, 0x2e, 0x92, 0x84, 0x30, 0x39, 0x7d, 0x55, 0x2a, 0x38, 0xfa, 0xe8,
+	0x5c, 0x95, 0x82, 0xc3, 0x84, 0x5a, 0xc1, 0x53, 0xbb, 0x6e, 0xaf, 0xe0, 0xf4, 0x00, 0xfd, 0x04,
+	0x75, 0x19, 0x5f, 0x8a, 0xa0, 0x3d, 0xea, 0x8c, 0x87, 0x93, 0x17, 0x0f, 0xad, 0x71, 0x11, 0xdb,
+	0x54, 0xf4, 0x4b, 0xa7, 0xa2, 0x4d, 0x4d, 0x2a, 0xba, 0xc2, 0xa9, 0x11, 0xa7, 0xc9, 0xcf, 0x32,
+	0xf4, 0xee, 0xcb, 0xd0, 0xfb, 0x53, 0x86, 0xde, 0xb7, 0x5d, 0xd8, 0xfa, 0xbe, 0x0b, 0x5b, 0xf7,
+	0xbb, 0xb0, 0xf5, 0x7b, 0x17, 0xb6, 0x3e, 0x4f, 0x32, 0x56, 0x5c, 0xaf, 0xaf, 0xa2, 0xb9, 0xc8,
+	0x63, 0xb3, 0xeb, 0x35, 0xa7, 0xc5, 0x57, 0x21, 0x6f, 0x5c, 0x45, 0x56, 0x2c, 0xce, 0xc4, 0x3f,
+	0x5f, 0xef, 0xaa, 0x67, 0xbe, 0xdb, 0xd9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7b, 0x7a, 0xa2,
+	0x61, 0xdf, 0x02, 0x00, 0x00,
 }
 
 func (m *GPUInfo) Marshal() (dAtA []byte, err error) {
diff --git a/go/inventory/v1/memory.pb.go b/go/inventory/v1/memory.pb.go
index 0b15525e..3f5511e3 100644
--- a/go/inventory/v1/memory.pb.go
+++ b/go/inventory/v1/memory.pb.go
@@ -6,7 +6,7 @@ package v1
 import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -21,13 +21,13 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type MemoryInfo struct {
-	Vendor string `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor" yaml:"vendor"`
-	Type   string `protobuf:"bytes,2,opt,name=type,proto3" json:"type" yaml:"type"`
-	Size_  string `protobuf:"bytes,3,opt,name=size,proto3" json:"size" yaml:"size"`
-	Speed  string `protobuf:"bytes,4,opt,name=speed,proto3" json:"speed" yaml:"speed"`
+	Vendor    string `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor" yaml:"vendor"`
+	Type      string `protobuf:"bytes,2,opt,name=type,proto3" json:"type" yaml:"type"`
+	TotalSize string `protobuf:"bytes,3,opt,name=totalsize,proto3" json:"totalsize" yaml:"totalsize"`
+	Speed     string `protobuf:"bytes,4,opt,name=speed,proto3" json:"speed" yaml:"speed"`
 }
 
 func (m *MemoryInfo) Reset()         { *m = MemoryInfo{} }
@@ -77,9 +77,9 @@ func (m *MemoryInfo) GetType() string {
 	return ""
 }
 
-func (m *MemoryInfo) GetSize_() string {
+func (m *MemoryInfo) GetTotalSize() string {
 	if m != nil {
-		return m.Size_
+		return m.TotalSize
 	}
 	return ""
 }
@@ -151,33 +151,34 @@ func init() {
 func init() { proto.RegisterFile("akash/inventory/v1/memory.proto", fileDescriptor_bf744888c94a0308) }
 
 var fileDescriptor_bf744888c94a0308 = []byte{
-	// 405 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x41, 0x8b, 0xda, 0x40,
-	0x1c, 0xc5, 0x8d, 0xc6, 0x60, 0xc7, 0x96, 0x42, 0xe8, 0x21, 0x78, 0xc8, 0xc8, 0x80, 0x20, 0x94,
-	0x26, 0xa8, 0x97, 0x52, 0xe8, 0xc5, 0x5b, 0xa1, 0x85, 0x36, 0x96, 0x1e, 0x7a, 0x8b, 0x3a, 0xc6,
-	0xc1, 0x4d, 0x26, 0x3b, 0x89, 0x59, 0xe2, 0xa7, 0xd8, 0x8f, 0xe5, 0xd1, 0xe3, 0x9e, 0x86, 0x25,
-	0xde, 0x72, 0x59, 0xc8, 0x27, 0x58, 0x66, 0x26, 0x6b, 0x58, 0xd6, 0x5b, 0xde, 0x7b, 0xff, 0xdf,
-	0xfc, 0x99, 0x97, 0x01, 0xd0, 0xdf, 0xf9, 0xc9, 0xd6, 0x25, 0x51, 0x86, 0xa3, 0x94, 0xb2, 0xdc,
-	0xcd, 0x26, 0x6e, 0x88, 0x43, 0xca, 0x72, 0x27, 0x66, 0x34, 0xa5, 0xa6, 0x29, 0x07, 0x9c, 0xcb,
-	0x80, 0x93, 0x4d, 0x06, 0x9f, 0x02, 0x1a, 0x50, 0x19, 0xbb, 0xe2, 0x4b, 0x4d, 0x0e, 0x46, 0x57,
-	0x8e, 0x62, 0x38, 0xa1, 0x7b, 0xb6, 0xc2, 0xb1, 0x4f, 0x98, 0x1a, 0x43, 0x4f, 0x1a, 0x00, 0xbf,
-	0xe4, 0x86, 0x1f, 0xd1, 0x86, 0x9a, 0xdf, 0x81, 0x91, 0xe1, 0x68, 0x4d, 0x99, 0xa5, 0x0d, 0xb5,
-	0xf1, 0xbb, 0xf9, 0xa8, 0xe0, 0xd0, 0xf8, 0x27, 0x9d, 0x92, 0xc3, 0x3a, 0xab, 0x38, 0xfc, 0x90,
-	0xfb, 0xe1, 0xcd, 0x37, 0xa4, 0x34, 0xf2, 0xea, 0xc0, 0x9c, 0x01, 0x3d, 0xcd, 0x63, 0x6c, 0xb5,
-	0x25, 0x0c, 0x0b, 0x0e, 0xf5, 0xbf, 0x79, 0x8c, 0x4b, 0x0e, 0xa5, 0x5f, 0x71, 0xd8, 0x57, 0xa0,
-	0x50, 0xc8, 0x93, 0xa6, 0x80, 0x12, 0x72, 0xc0, 0x56, 0xa7, 0x81, 0x16, 0xe4, 0x20, 0x21, 0xe1,
-	0x37, 0x90, 0x50, 0xc8, 0x93, 0xa6, 0xf9, 0x15, 0x74, 0x93, 0x18, 0xe3, 0xb5, 0xa5, 0x4b, 0x0a,
-	0x15, 0x1c, 0x76, 0x17, 0xc2, 0x28, 0x39, 0x54, 0x49, 0xc5, 0xe1, 0xfb, 0x9a, 0x13, 0x12, 0x79,
-	0xca, 0x46, 0x47, 0x0d, 0x18, 0xea, 0xc6, 0x26, 0x01, 0xbd, 0xdb, 0xbd, 0x1f, 0xa5, 0x24, 0xcd,
-	0xe5, 0x7d, 0xfb, 0xd3, 0xa1, 0xf3, 0xb6, 0x60, 0xc7, 0xab, 0x6b, 0xfb, 0xed, 0x13, 0x36, 0xff,
-	0x5c, 0x70, 0xd8, 0xfb, 0x53, 0x53, 0x25, 0x87, 0x97, 0x13, 0x2a, 0x0e, 0x3f, 0xaa, 0x7d, 0x2f,
-	0x0e, 0xf2, 0x2e, 0xa1, 0xb9, 0x00, 0x3a, 0x89, 0x36, 0xd4, 0x6a, 0x0f, 0x3b, 0xe3, 0xfe, 0xd4,
-	0xbe, 0xb6, 0xa6, 0xf9, 0x0d, 0xaa, 0x04, 0xf1, 0x25, 0x4a, 0x10, 0x5c, 0x53, 0x82, 0x50, 0xc8,
-	0x93, 0xe6, 0xfc, 0xe7, 0xb1, 0xb0, 0xb5, 0x53, 0x61, 0x6b, 0x8f, 0x85, 0xad, 0xdd, 0x9f, 0xed,
-	0xd6, 0xe9, 0x6c, 0xb7, 0x1e, 0xce, 0x76, 0xeb, 0xff, 0x34, 0x20, 0xe9, 0x76, 0xbf, 0x74, 0x56,
-	0x34, 0x74, 0xe5, 0xaa, 0x2f, 0x11, 0x4e, 0xef, 0x28, 0xdb, 0xd5, 0xca, 0x8f, 0x89, 0x1b, 0xd0,
-	0x57, 0xaf, 0x63, 0x69, 0xc8, 0x17, 0x31, 0x7b, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x57, 0x57, 0x22,
-	0x9e, 0x85, 0x02, 0x00, 0x00,
+	// 424 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0xbf, 0x6a, 0x1b, 0x31,
+	0x18, 0xf7, 0x39, 0x8e, 0x89, 0xe5, 0x96, 0x16, 0xd1, 0xe1, 0xc8, 0xa0, 0xcf, 0x08, 0x02, 0x81,
+	0xd2, 0x3b, 0xe2, 0x2c, 0xa5, 0xd0, 0xc5, 0x5b, 0xa1, 0x85, 0xf4, 0x1c, 0x3a, 0x74, 0x53, 0x12,
+	0xc5, 0x11, 0x89, 0x4f, 0x57, 0x59, 0x76, 0xb9, 0x3c, 0x41, 0xc7, 0x8e, 0x7d, 0xa4, 0x8c, 0x19,
+	0x3b, 0x89, 0xa2, 0xdb, 0x6e, 0xbc, 0x27, 0x28, 0x92, 0x2e, 0x3e, 0x4a, 0xbd, 0xdd, 0xef, 0xef,
+	0x07, 0xbf, 0x13, 0x02, 0x76, 0xcb, 0x56, 0x37, 0xa9, 0xc8, 0x37, 0x3c, 0xd7, 0x52, 0x95, 0xe9,
+	0xe6, 0x24, 0x5d, 0xf2, 0xa5, 0x54, 0x65, 0x52, 0x28, 0xa9, 0x25, 0xc6, 0xde, 0x90, 0x6c, 0x0d,
+	0xc9, 0xe6, 0xe4, 0xf0, 0xd5, 0x42, 0x2e, 0xa4, 0x97, 0x53, 0xf7, 0x15, 0x9c, 0x87, 0x47, 0x3b,
+	0xaa, 0x14, 0x5f, 0xc9, 0xb5, 0xba, 0xe4, 0x05, 0x13, 0x2a, 0xd8, 0xe8, 0x8f, 0x3e, 0x42, 0x9f,
+	0xfc, 0x85, 0x0f, 0xf9, 0xb5, 0xc4, 0xef, 0xd1, 0x70, 0xc3, 0xf3, 0x2b, 0xa9, 0xe2, 0x68, 0x12,
+	0x1d, 0x8f, 0x66, 0x47, 0xd6, 0xc0, 0xf0, 0x8b, 0x67, 0x6a, 0x03, 0xad, 0xd6, 0x18, 0x78, 0x5e,
+	0xb2, 0xe5, 0xdd, 0x3b, 0x1a, 0x30, 0xcd, 0x5a, 0x01, 0x9f, 0xa2, 0x81, 0x2e, 0x0b, 0x1e, 0xf7,
+	0x7d, 0x18, 0xac, 0x81, 0xc1, 0x79, 0x59, 0xf0, 0xda, 0x80, 0xe7, 0x1b, 0x03, 0xe3, 0x10, 0x74,
+	0x88, 0x66, 0x9e, 0xc4, 0x1f, 0xd1, 0x48, 0x4b, 0xcd, 0xee, 0x56, 0xe2, 0x9e, 0xc7, 0x7b, 0x3e,
+	0x99, 0x58, 0x03, 0xa3, 0x73, 0x47, 0xce, 0xc5, 0xbd, 0x8b, 0x77, 0x8e, 0xc6, 0xc0, 0xcb, 0xb6,
+	0xe3, 0x89, 0xa2, 0x59, 0x27, 0xe3, 0xb7, 0x68, 0x7f, 0x55, 0x70, 0x7e, 0x15, 0x0f, 0x7c, 0x13,
+	0xb5, 0x06, 0xf6, 0xe7, 0x8e, 0xa8, 0x0d, 0x04, 0xa5, 0x31, 0xf0, 0x2c, 0x34, 0x78, 0x48, 0xb3,
+	0x40, 0xd3, 0x87, 0x08, 0x0d, 0xc3, 0x14, 0x58, 0xa0, 0x83, 0x6f, 0x6b, 0x96, 0x6b, 0xa1, 0x4b,
+	0x3f, 0xc4, 0x78, 0x3a, 0x49, 0xfe, 0x5f, 0x3e, 0xc9, 0xda, 0x3d, 0xcf, 0x98, 0x50, 0xb3, 0xd7,
+	0xd6, 0xc0, 0xc1, 0xe7, 0x36, 0x55, 0x1b, 0xd8, 0x36, 0x34, 0x06, 0x5e, 0x84, 0x7b, 0x4f, 0x0c,
+	0xcd, 0xb6, 0x22, 0x9e, 0xa3, 0x81, 0xc8, 0xaf, 0x65, 0xdc, 0x9f, 0xec, 0x1d, 0x8f, 0xa7, 0x64,
+	0xd7, 0x99, 0xee, 0xff, 0x84, 0x49, 0xdd, 0x97, 0x9b, 0xd4, 0xe5, 0xba, 0x49, 0x1d, 0xa2, 0x99,
+	0x27, 0x67, 0x67, 0x0f, 0x96, 0x44, 0x8f, 0x96, 0x44, 0x7f, 0x2c, 0x89, 0x7e, 0x56, 0xa4, 0xf7,
+	0xab, 0x22, 0xbd, 0xc7, 0x8a, 0xf4, 0x7e, 0x57, 0xa4, 0xf7, 0x75, 0xba, 0x10, 0xfa, 0x66, 0x7d,
+	0x91, 0x5c, 0xca, 0x65, 0xea, 0xcf, 0xbd, 0xc9, 0xb9, 0xfe, 0x2e, 0xd5, 0x6d, 0x8b, 0x58, 0x21,
+	0xd2, 0x85, 0xfc, 0xe7, 0xe9, 0x5c, 0x0c, 0xfd, 0x73, 0x39, 0xfd, 0x1b, 0x00, 0x00, 0xff, 0xff,
+	0x64, 0x85, 0x3a, 0xdc, 0xa2, 0x02, 0x00, 0x00,
 }
 
 func (m *MemoryInfo) Marshal() (dAtA []byte, err error) {
@@ -207,10 +208,10 @@ func (m *MemoryInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x22
 	}
-	if len(m.Size_) > 0 {
-		i -= len(m.Size_)
-		copy(dAtA[i:], m.Size_)
-		i = encodeVarintMemory(dAtA, i, uint64(len(m.Size_)))
+	if len(m.TotalSize) > 0 {
+		i -= len(m.TotalSize)
+		copy(dAtA[i:], m.TotalSize)
+		i = encodeVarintMemory(dAtA, i, uint64(len(m.TotalSize)))
 		i--
 		dAtA[i] = 0x1a
 	}
@@ -305,7 +306,7 @@ func (m *MemoryInfo) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovMemory(uint64(l))
 	}
-	l = len(m.Size_)
+	l = len(m.TotalSize)
 	if l > 0 {
 		n += 1 + l + sovMemory(uint64(l))
 	}
@@ -436,7 +437,7 @@ func (m *MemoryInfo) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TotalSize", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -464,7 +465,7 @@ func (m *MemoryInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Size_ = string(dAtA[iNdEx:postIndex])
+			m.TotalSize = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
diff --git a/go/inventory/v1/node.pb.go b/go/inventory/v1/node.pb.go
index 2044b47d..cfa9de7f 100644
--- a/go/inventory/v1/node.pb.go
+++ b/go/inventory/v1/node.pb.go
@@ -6,7 +6,7 @@ package v1
 import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -21,7 +21,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type Node struct {
 	CPU     CPU     `protobuf:"bytes,1,opt,name=cpu,proto3,castrepeated=CPUs" json:"cpu" yaml:"cpu"`
@@ -98,32 +98,32 @@ func init() {
 func init() { proto.RegisterFile("akash/inventory/v1/node.proto", fileDescriptor_5f97c0fb35079221) }
 
 var fileDescriptor_5f97c0fb35079221 = []byte{
-	// 385 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xc1, 0x6a, 0xa3, 0x40,
-	0x1c, 0xc6, 0x75, 0x95, 0x04, 0x0c, 0xbb, 0x07, 0x59, 0x58, 0x71, 0x77, 0x9d, 0x90, 0x53, 0xa0,
-	0x54, 0x49, 0x72, 0x28, 0xf4, 0x68, 0x0e, 0xb9, 0xb4, 0x45, 0x12, 0xec, 0xa1, 0x37, 0x63, 0x64,
-	0x12, 0x52, 0x9d, 0x41, 0x9d, 0x94, 0xbc, 0x43, 0x0f, 0x7d, 0x8e, 0x3e, 0x49, 0x8e, 0x39, 0xf6,
-	0x34, 0x2d, 0xe6, 0xe6, 0xd1, 0x27, 0x28, 0xce, 0x4c, 0x02, 0xa5, 0xb6, 0x37, 0xff, 0xf3, 0xfd,
-	0xfe, 0xdf, 0xf7, 0x8d, 0xa3, 0xfd, 0x0f, 0xd6, 0x41, 0xb6, 0x74, 0x56, 0xc9, 0x26, 0x4a, 0x72,
-	0x94, 0x6e, 0x9d, 0xcd, 0xc0, 0x49, 0xd0, 0x22, 0xb2, 0x71, 0x8a, 0x72, 0xa4, 0xeb, 0x4c, 0xb6,
-	0x4f, 0xb2, 0xbd, 0x19, 0x98, 0xbf, 0x21, 0x82, 0x88, 0xc9, 0x4e, 0xfd, 0xc5, 0x49, 0xf3, 0x5f,
-	0x83, 0x51, 0x88, 0xc9, 0x37, 0x2a, 0x3c, 0xa9, 0xdd, 0x06, 0x35, 0xcb, 0x51, 0x1a, 0x40, 0xd1,
-	0xc3, 0x04, 0x0d, 0x44, 0x1c, 0xc5, 0x75, 0x23, 0x06, 0xf4, 0x1e, 0x15, 0x4d, 0xbd, 0x41, 0x8b,
-	0x48, 0x9f, 0x69, 0x4a, 0x88, 0x89, 0x21, 0x77, 0xe5, 0x7e, 0x67, 0xf8, 0xc7, 0xfe, 0xdc, 0xdf,
-	0x1e, 0x7b, 0xbe, 0xdb, 0xdf, 0x51, 0x20, 0x15, 0x14, 0x28, 0x63, 0xcf, 0x2f, 0x29, 0xa8, 0x57,
-	0x2a, 0x0a, 0xb4, 0x6d, 0x10, 0xdf, 0x5f, 0xf6, 0x42, 0x4c, 0x7a, 0xcf, 0xaf, 0x40, 0x1d, 0x7b,
-	0x7e, 0x36, 0xad, 0x25, 0x1d, 0x6a, 0x2d, 0x9e, 0x66, 0xfc, 0x60, 0xbe, 0x66, 0x93, 0xef, 0x35,
-	0x23, 0xdc, 0x91, 0xb0, 0x6e, 0xf1, 0xb9, 0xa4, 0x40, 0xec, 0x56, 0x14, 0xfc, 0xe4, 0x01, 0x7c,
-	0xae, 0x33, 0x04, 0x34, 0x15, 0x88, 0x7e, 0xab, 0x29, 0x10, 0x13, 0x43, 0xf9, 0xba, 0xfd, 0xc4,
-	0xf3, 0xdd, 0x33, 0x11, 0xa1, 0x4e, 0x30, 0xc9, 0x4a, 0x0a, 0x54, 0x88, 0x49, 0x56, 0x51, 0xd0,
-	0xe1, 0xf6, 0xf5, 0xc4, 0x2e, 0x30, 0x61, 0x17, 0x80, 0x98, 0xe8, 0x89, 0xd6, 0x16, 0x3f, 0xd4,
-	0x50, 0x99, 0xf7, 0xdf, 0x26, 0xef, 0x19, 0x47, 0xdc, 0x0b, 0xe1, 0xdf, 0x16, 0x07, 0x25, 0x05,
-	0xc7, 0xf5, 0x8a, 0x82, 0x5f, 0x3c, 0x45, 0x1c, 0xd4, 0x41, 0x47, 0x6e, 0x7a, 0xa4, 0xdc, 0xab,
-	0x5d, 0x61, 0xc9, 0xfb, 0xc2, 0x92, 0xdf, 0x0a, 0x4b, 0x7e, 0x3a, 0x58, 0xd2, 0xfe, 0x60, 0x49,
-	0x2f, 0x07, 0x4b, 0xba, 0x1b, 0xc2, 0x55, 0xbe, 0x24, 0x73, 0x3b, 0x44, 0xb1, 0xc3, 0x2a, 0x9c,
-	0x27, 0x51, 0xfe, 0x80, 0xd2, 0xb5, 0x98, 0x02, 0xbc, 0x72, 0x20, 0xfa, 0xf0, 0xd2, 0xf3, 0x16,
-	0x7b, 0xe3, 0xd1, 0x7b, 0x00, 0x00, 0x00, 0xff, 0xff, 0x69, 0x72, 0x8d, 0xb4, 0xad, 0x02, 0x00,
-	0x00,
+	// 389 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xb1, 0x6e, 0x9b, 0x40,
+	0x1c, 0xc6, 0xa1, 0x20, 0x5b, 0xc2, 0x6a, 0x07, 0x54, 0xa9, 0x88, 0xb6, 0x9c, 0xe5, 0xc9, 0x52,
+	0x55, 0x90, 0xed, 0xa1, 0x52, 0x47, 0x3c, 0x78, 0x4a, 0x84, 0x6c, 0x91, 0x21, 0x1b, 0xc6, 0xe8,
+	0x6c, 0x39, 0x70, 0x27, 0xe0, 0x1c, 0xf9, 0x1d, 0x32, 0x64, 0xcc, 0x33, 0xe4, 0x49, 0x3c, 0x7a,
+	0xcc, 0x74, 0x89, 0x60, 0x63, 0xe4, 0x09, 0x22, 0xee, 0xce, 0x96, 0xa2, 0x90, 0x6c, 0xfc, 0xef,
+	0xfb, 0xfd, 0xbf, 0xef, 0x3b, 0x4e, 0xfb, 0x1d, 0x6c, 0x83, 0x6c, 0xed, 0x6c, 0x92, 0x5d, 0x94,
+	0xe4, 0x28, 0xdd, 0x3b, 0xbb, 0x91, 0x93, 0xa0, 0x55, 0x64, 0xe3, 0x14, 0xe5, 0x48, 0xd7, 0x99,
+	0x6c, 0x9f, 0x65, 0x7b, 0x37, 0x32, 0xbf, 0x43, 0x04, 0x11, 0x93, 0x9d, 0xe6, 0x8b, 0x93, 0xe6,
+	0xaf, 0x16, 0xa3, 0x10, 0x93, 0x4f, 0x54, 0x78, 0x56, 0xfb, 0x2d, 0x6a, 0x96, 0xa3, 0x34, 0x80,
+	0xa2, 0x87, 0x09, 0x5a, 0x88, 0x38, 0x8a, 0x9b, 0x46, 0x0c, 0x18, 0xdc, 0x29, 0x9a, 0x7a, 0x89,
+	0x56, 0x91, 0xbe, 0xd0, 0x94, 0x10, 0x13, 0x43, 0xee, 0xcb, 0xc3, 0xde, 0xf8, 0x87, 0xfd, 0xbe,
+	0xbf, 0x3d, 0xf5, 0x7c, 0x77, 0x78, 0xa0, 0x40, 0x2a, 0x28, 0x50, 0xa6, 0x9e, 0x5f, 0x51, 0xd0,
+	0xac, 0xd4, 0x14, 0x68, 0xfb, 0x20, 0xbe, 0xf9, 0x3f, 0x08, 0x31, 0x19, 0x3c, 0x3e, 0x03, 0x75,
+	0xea, 0xf9, 0xd9, 0xbc, 0x91, 0x74, 0xa8, 0x75, 0x78, 0x9a, 0xf1, 0x85, 0xf9, 0x9a, 0x6d, 0xbe,
+	0x17, 0x8c, 0x70, 0x27, 0xc2, 0xba, 0xc3, 0xe7, 0x8a, 0x02, 0xb1, 0x5b, 0x53, 0xf0, 0x95, 0x07,
+	0xf0, 0xb9, 0xc9, 0x10, 0xd0, 0x5c, 0x20, 0xfa, 0x95, 0xa6, 0x40, 0x4c, 0x0c, 0xe5, 0xe3, 0xf6,
+	0x33, 0xcf, 0x77, 0xff, 0x88, 0x08, 0x75, 0x86, 0x49, 0x56, 0x51, 0xa0, 0x42, 0x4c, 0xb2, 0x9a,
+	0x82, 0x1e, 0xb7, 0x6f, 0x26, 0x76, 0x81, 0x19, 0xbb, 0x00, 0xc4, 0x44, 0x4f, 0xb4, 0xae, 0xf8,
+	0xa1, 0x86, 0xca, 0xbc, 0x7f, 0xb6, 0x79, 0x2f, 0x38, 0xe2, 0xfe, 0x13, 0xfe, 0x5d, 0x71, 0x50,
+	0x51, 0x70, 0x5a, 0xaf, 0x29, 0xf8, 0xc6, 0x53, 0xc4, 0x41, 0x13, 0x74, 0xe2, 0xe6, 0x27, 0xca,
+	0xf5, 0x0e, 0x85, 0x25, 0x1f, 0x0b, 0x4b, 0x7e, 0x29, 0x2c, 0xf9, 0xbe, 0xb4, 0xa4, 0x87, 0xd2,
+	0x92, 0x8e, 0xa5, 0x25, 0x3d, 0x95, 0x96, 0x74, 0x3d, 0x86, 0x9b, 0x7c, 0x4d, 0x96, 0x76, 0x88,
+	0x62, 0x87, 0xd5, 0xf8, 0x9b, 0x44, 0xf9, 0x2d, 0x4a, 0xb7, 0x62, 0x0a, 0xf0, 0xc6, 0x81, 0xe8,
+	0xcd, 0x6b, 0x2f, 0x3b, 0xec, 0x9d, 0x27, 0xaf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x79, 0xf9, 0x98,
+	0x31, 0xb1, 0x02, 0x00, 0x00,
 }
 
 func (m *Node) Marshal() (dAtA []byte, err error) {
diff --git a/go/inventory/v1/resourcepair.pb.go b/go/inventory/v1/resourcepair.pb.go
index 88fe7dfe..657ec514 100644
--- a/go/inventory/v1/resourcepair.pb.go
+++ b/go/inventory/v1/resourcepair.pb.go
@@ -5,10 +5,9 @@ package v1
 
 import (
 	fmt "fmt"
-	github_com_akash_network_akash_api_go_node_types_v1beta3 "github.com/akash-network/akash-api/go/node/types/v1beta3"
 	v1beta3 "github.com/akash-network/akash-api/go/node/types/v1beta3"
 	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	resource "k8s.io/apimachinery/pkg/api/resource"
 	math "math"
@@ -24,12 +23,12 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type ResourcePair struct {
-	Allocatable resource.Quantity                                                   `protobuf:"bytes,1,opt,name=allocatable,proto3" json:"allocatable" yaml:"allocatable"`
-	Allocated   resource.Quantity                                                   `protobuf:"bytes,2,opt,name=allocated,proto3" json:"allocated" yaml:"allocated"`
-	Attributes  github_com_akash_network_akash_api_go_node_types_v1beta3.Attributes `protobuf:"bytes,3,rep,name=attributes,proto3,castrepeated=github.com/akash-network/akash-api/go/node/types/v1beta3.Attributes" json:"attributes,omitempty" yaml:"attributes,omitempty"`
+	Allocatable resource.Quantity   `protobuf:"bytes,1,opt,name=allocatable,proto3" json:"allocatable" yaml:"allocatable"`
+	Allocated   resource.Quantity   `protobuf:"bytes,2,opt,name=allocated,proto3" json:"allocated" yaml:"allocated"`
+	Attributes  []v1beta3.Attribute `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty" yaml:"attributes,omitempty"`
 }
 
 func (m *ResourcePair) Reset()         { *m = ResourcePair{} }
@@ -79,7 +78,7 @@ func (m *ResourcePair) GetAllocated() resource.Quantity {
 	return resource.Quantity{}
 }
 
-func (m *ResourcePair) GetAttributes() github_com_akash_network_akash_api_go_node_types_v1beta3.Attributes {
+func (m *ResourcePair) GetAttributes() []v1beta3.Attribute {
 	if m != nil {
 		return m.Attributes
 	}
@@ -95,34 +94,33 @@ func init() {
 }
 
 var fileDescriptor_995cee7bf7b692e7 = []byte{
-	// 425 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x52, 0x3d, 0x8f, 0xd3, 0x30,
-	0x18, 0x8e, 0x29, 0x42, 0xba, 0x94, 0x01, 0x45, 0x37, 0x54, 0x87, 0x88, 0x4f, 0x91, 0x90, 0x6e,
-	0x00, 0x5b, 0xed, 0x31, 0x9c, 0x6e, 0x6b, 0x59, 0x19, 0x20, 0x23, 0x9b, 0x93, 0xbc, 0x4a, 0xad,
-	0x7c, 0x38, 0x72, 0x9c, 0xa0, 0x6c, 0x88, 0x91, 0x89, 0x9f, 0xc0, 0xcc, 0xcf, 0x60, 0xea, 0xd8,
-	0x91, 0xc9, 0xa0, 0x74, 0x81, 0x8e, 0xfd, 0x05, 0x28, 0x1f, 0x6d, 0x82, 0x60, 0x40, 0xb7, 0xd9,
-	0xef, 0xfb, 0x7c, 0x49, 0xcf, 0x6b, 0x3e, 0x65, 0x11, 0xcb, 0xd7, 0x94, 0xa7, 0x25, 0xa4, 0x4a,
-	0xc8, 0x8a, 0x96, 0x73, 0x2a, 0x21, 0x17, 0x85, 0xf4, 0x21, 0x63, 0x5c, 0x92, 0x4c, 0x0a, 0x25,
-	0x2c, 0xab, 0x85, 0x91, 0x13, 0x8c, 0x94, 0xf3, 0x0b, 0xa7, 0xa3, 0x7a, 0x2c, 0x07, 0x5a, 0xce,
-	0x3d, 0x50, 0xec, 0x9a, 0x32, 0xa5, 0x24, 0xf7, 0x0a, 0x05, 0x1d, 0xef, 0xe2, 0x3c, 0x14, 0xa1,
-	0x68, 0x9f, 0xb4, 0x79, 0xf5, 0xd3, 0x17, 0xd1, 0x4d, 0x4e, 0xb8, 0xa0, 0x2c, 0xe3, 0x09, 0xf3,
-	0xd7, 0x3c, 0x05, 0x59, 0xd1, 0x2c, 0x0a, 0x9b, 0xc1, 0xc9, 0x9d, 0x86, 0x90, 0x82, 0x64, 0x0a,
-	0x82, 0x8e, 0xe5, 0xfc, 0x9a, 0x98, 0x0f, 0xdd, 0x7e, 0xf9, 0x9a, 0x71, 0x69, 0x7d, 0x44, 0xe6,
-	0x94, 0xc5, 0xb1, 0xf0, 0x99, 0x62, 0x5e, 0x0c, 0x33, 0x74, 0x89, 0xae, 0xa6, 0x0b, 0x42, 0x3a,
-	0x75, 0x32, 0x56, 0x27, 0x59, 0x14, 0x36, 0x03, 0x72, 0x54, 0x27, 0x6f, 0x0a, 0x96, 0x2a, 0xae,
-	0xaa, 0xd5, 0xcd, 0x46, 0x63, 0xa3, 0xd6, 0x78, 0xba, 0x1c, 0xa4, 0xf6, 0x1a, 0x8f, 0x95, 0x0f,
-	0x1a, 0x5b, 0x15, 0x4b, 0xe2, 0x5b, 0x67, 0x34, 0x74, 0xdc, 0x31, 0xc4, 0x7a, 0x8f, 0xcc, 0xb3,
-	0xfe, 0x0f, 0xc1, 0xec, 0xde, 0x9d, 0xa2, 0x2c, 0xfa, 0x28, 0x67, 0xcb, 0xa3, 0xd0, 0x5e, 0xe3,
-	0x41, 0xf5, 0xa0, 0xf1, 0xa3, 0x3f, 0x62, 0x40, 0xe0, 0xb8, 0xc3, 0xda, 0xfa, 0x8a, 0x4c, 0xf3,
-	0x54, 0x40, 0x3e, 0x9b, 0x5c, 0x4e, 0xae, 0xa6, 0x8b, 0x27, 0xa4, 0xab, 0xae, 0xa9, 0x89, 0xf4,
-	0x35, 0x91, 0xe5, 0x11, 0xb5, 0xfa, 0x80, 0x36, 0x1a, 0xa3, 0xbd, 0xc6, 0xe7, 0x03, 0xf3, 0x99,
-	0x48, 0xb8, 0x82, 0x24, 0x53, 0xd5, 0x41, 0xe3, 0xc7, 0xbd, 0xe3, 0x3f, 0xb6, 0xce, 0x97, 0xef,
-	0xf8, 0x65, 0xc8, 0xd5, 0xba, 0xf0, 0x88, 0x2f, 0x12, 0xda, 0x1a, 0x3d, 0x4f, 0x41, 0xbd, 0x13,
-	0x32, 0xea, 0x7f, 0x4d, 0xa3, 0xa1, 0xa0, 0xa9, 0x08, 0x80, 0xaa, 0x2a, 0x83, 0x9c, 0xfe, 0x95,
-	0x21, 0x77, 0x47, 0xa9, 0x6f, 0xef, 0xff, 0xfc, 0x8c, 0x8d, 0xd5, 0xab, 0x4d, 0x6d, 0xa3, 0x6d,
-	0x6d, 0xa3, 0x1f, 0xb5, 0x8d, 0x3e, 0xed, 0x6c, 0x63, 0xbb, 0xb3, 0x8d, 0x6f, 0x3b, 0xdb, 0x78,
-	0xbb, 0xf8, 0x3f, 0xc3, 0xf1, 0x41, 0x7b, 0x0f, 0xda, 0x03, 0xba, 0xfe, 0x1d, 0x00, 0x00, 0xff,
-	0xff, 0xc1, 0xb0, 0xd7, 0x21, 0xed, 0x02, 0x00, 0x00,
+	// 403 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x52, 0x3d, 0xef, 0x93, 0x40,
+	0x18, 0x07, 0x6b, 0x4c, 0xfe, 0xe0, 0x60, 0x48, 0x87, 0xa6, 0x46, 0xae, 0x21, 0x31, 0xe9, 0xa0,
+	0x77, 0x29, 0x75, 0x68, 0xea, 0xd4, 0x7e, 0x82, 0xca, 0xe8, 0x76, 0xd0, 0x0b, 0xbd, 0xf0, 0x72,
+	0xe4, 0x38, 0x30, 0x38, 0x39, 0x3b, 0x39, 0x3a, 0xf6, 0xe3, 0x74, 0xec, 0xe8, 0x74, 0x31, 0xb0,
+	0x98, 0x8e, 0xfd, 0x04, 0x86, 0x97, 0x16, 0x9a, 0x38, 0xb9, 0xdd, 0xf3, 0x3c, 0xbf, 0xb7, 0xf0,
+	0x43, 0x7b, 0x8b, 0x03, 0x9c, 0x1e, 0x10, 0x8d, 0x73, 0x12, 0x0b, 0xc6, 0x0b, 0x94, 0x2f, 0x10,
+	0x27, 0x29, 0xcb, 0xb8, 0x47, 0x12, 0x4c, 0x39, 0x4c, 0x38, 0x13, 0xcc, 0x30, 0x1a, 0x18, 0xbc,
+	0xc3, 0x60, 0xbe, 0x98, 0x5a, 0x2d, 0xd5, 0xc5, 0x29, 0x41, 0xf9, 0xc2, 0x25, 0x02, 0x2f, 0x11,
+	0x16, 0x82, 0x53, 0x37, 0x13, 0xa4, 0xe5, 0x4d, 0xc7, 0x3e, 0xf3, 0x59, 0xf3, 0x44, 0xf5, 0xab,
+	0xdb, 0x7e, 0x08, 0x56, 0x29, 0xa4, 0x0c, 0xe1, 0x84, 0x46, 0xd8, 0x3b, 0xd0, 0x98, 0xf0, 0x02,
+	0x25, 0x81, 0x5f, 0x2f, 0xee, 0xee, 0xc8, 0x27, 0x31, 0xe1, 0x58, 0x90, 0x7d, 0xcb, 0xb2, 0x8e,
+	0x23, 0xed, 0xa5, 0xd3, 0x1d, 0x77, 0x98, 0x72, 0xe3, 0xbb, 0xaa, 0xe9, 0x38, 0x0c, 0x99, 0x87,
+	0x05, 0x76, 0x43, 0x32, 0x51, 0x67, 0xea, 0x5c, 0xb7, 0x21, 0x6c, 0xd5, 0xe1, 0x50, 0x1d, 0x26,
+	0x81, 0x5f, 0x2f, 0xe0, 0x4d, 0x1d, 0x7e, 0xca, 0x70, 0x2c, 0xa8, 0x28, 0xb6, 0xab, 0x93, 0x04,
+	0x4a, 0x29, 0x81, 0xbe, 0xe9, 0xa5, 0x2e, 0x12, 0x0c, 0x95, 0xaf, 0x12, 0x18, 0x05, 0x8e, 0xc2,
+	0xb5, 0x35, 0x58, 0x5a, 0xce, 0x10, 0x62, 0x7c, 0x53, 0xb5, 0xa7, 0x6e, 0x26, 0xfb, 0xc9, 0xb3,
+	0xff, 0x8a, 0x62, 0x77, 0x51, 0x9e, 0x36, 0x37, 0xa1, 0x8b, 0x04, 0xbd, 0xea, 0x55, 0x82, 0x57,
+	0x0f, 0x31, 0xc8, 0xde, 0x72, 0xfa, 0xb3, 0xf1, 0x55, 0xd3, 0xee, 0xdf, 0x3f, 0x9d, 0x8c, 0x66,
+	0xa3, 0xb9, 0x6e, 0xbf, 0x81, 0x6d, 0x73, 0x75, 0x4b, 0xb0, 0x6b, 0x09, 0x6e, 0x6e, 0xa8, 0xed,
+	0xc7, 0xda, 0xf1, 0x22, 0xc1, 0xb8, 0x27, 0xbe, 0x63, 0x11, 0x15, 0x24, 0x4a, 0x44, 0x71, 0x95,
+	0xe0, 0x75, 0xe7, 0xf7, 0x8f, 0xab, 0xe5, 0x0c, 0xdc, 0xd6, 0xcf, 0xff, 0x1c, 0x81, 0xb2, 0xdd,
+	0x9d, 0x4a, 0x53, 0x3d, 0x97, 0xa6, 0xfa, 0xbb, 0x34, 0xd5, 0x1f, 0x95, 0xa9, 0xfc, 0xac, 0x4c,
+	0xe5, 0x5c, 0x99, 0xca, 0xaf, 0xca, 0x54, 0x3e, 0xdb, 0x3e, 0x15, 0x87, 0xcc, 0x85, 0x1e, 0x8b,
+	0x50, 0x93, 0xea, 0x7d, 0x4c, 0xc4, 0x17, 0xc6, 0x83, 0x6e, 0xaa, 0xdb, 0xf7, 0xd9, 0xc3, 0xbf,
+	0xe8, 0xbe, 0x68, 0xba, 0x5f, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x13, 0xd9, 0x6a, 0x62, 0xa8,
+	0x02, 0x00, 0x00,
 }
 
 func (m *ResourcePair) Marshal() (dAtA []byte, err error) {
@@ -342,7 +340,7 @@ func (m *ResourcePair) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Attributes = append(m.Attributes, &v1beta3.Attribute{})
+			m.Attributes = append(m.Attributes, v1beta3.Attribute{})
 			if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/go/inventory/v1/service.pb.go b/go/inventory/v1/service.pb.go
new file mode 100644
index 00000000..ffe06c2b
--- /dev/null
+++ b/go/inventory/v1/service.pb.go
@@ -0,0 +1,380 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: akash/inventory/v1/service.proto
+
+package v1
+
+import (
+	context "context"
+	fmt "fmt"
+	grpc1 "github.com/gogo/protobuf/grpc"
+	proto "github.com/gogo/protobuf/proto"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+type VoidNoParam struct {
+}
+
+func (m *VoidNoParam) Reset()         { *m = VoidNoParam{} }
+func (m *VoidNoParam) String() string { return proto.CompactTextString(m) }
+func (*VoidNoParam) ProtoMessage()    {}
+func (*VoidNoParam) Descriptor() ([]byte, []int) {
+	return fileDescriptor_19b1fad552cee5dc, []int{0}
+}
+func (m *VoidNoParam) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *VoidNoParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_VoidNoParam.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 *VoidNoParam) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VoidNoParam.Merge(m, src)
+}
+func (m *VoidNoParam) XXX_Size() int {
+	return m.Size()
+}
+func (m *VoidNoParam) XXX_DiscardUnknown() {
+	xxx_messageInfo_VoidNoParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VoidNoParam proto.InternalMessageInfo
+
+func init() {
+	proto.RegisterType((*VoidNoParam)(nil), "akash.inventory.v1.voidNoParam")
+}
+
+func init() { proto.RegisterFile("akash/inventory/v1/service.proto", fileDescriptor_19b1fad552cee5dc) }
+
+var fileDescriptor_19b1fad552cee5dc = []byte{
+	// 195 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x48, 0xcc, 0x4e, 0x2c,
+	0xce, 0xd0, 0xcf, 0xcc, 0x2b, 0x4b, 0xcd, 0x2b, 0xc9, 0x2f, 0xaa, 0xd4, 0x2f, 0x33, 0xd4, 0x2f,
+	0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x02, 0xab,
+	0xd0, 0x83, 0xab, 0xd0, 0x2b, 0x33, 0x94, 0x92, 0xc5, 0xa2, 0x2b, 0x2f, 0x3f, 0x05, 0xaa, 0x45,
+	0x89, 0x97, 0x8b, 0xbb, 0x2c, 0x3f, 0x33, 0xc5, 0x2f, 0x3f, 0x20, 0xb1, 0x28, 0x31, 0xd7, 0xc8,
+	0x9f, 0x8b, 0xd9, 0xb7, 0x38, 0x5d, 0xc8, 0x83, 0x8b, 0x33, 0xb0, 0x34, 0xb5, 0xa8, 0xd2, 0x2f,
+	0x3f, 0x25, 0x55, 0x48, 0x5e, 0x0f, 0xd3, 0x58, 0x3d, 0x24, 0x4d, 0x52, 0x12, 0xd8, 0x14, 0x80,
+	0xb4, 0x1a, 0x30, 0x3a, 0xf9, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47,
+	0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94,
+	0x51, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x58, 0xbf, 0x6e, 0x5e,
+	0x6a, 0x49, 0x79, 0x7e, 0x51, 0x36, 0x94, 0x97, 0x58, 0x90, 0xa9, 0x9f, 0x9e, 0x8f, 0xe2, 0xf0,
+	0x24, 0x36, 0xb0, 0xa3, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb1, 0x12, 0x83, 0xba, 0x0b,
+	0x01, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type MsgClient interface {
+	// QueryNode defines a method to query an Akash Provider worker node specs
+	QueryNode(ctx context.Context, in *VoidNoParam, opts ...grpc.CallOption) (Msg_QueryNodeClient, error)
+}
+
+type msgClient struct {
+	cc grpc1.ClientConn
+}
+
+func NewMsgClient(cc grpc1.ClientConn) MsgClient {
+	return &msgClient{cc}
+}
+
+func (c *msgClient) QueryNode(ctx context.Context, in *VoidNoParam, opts ...grpc.CallOption) (Msg_QueryNodeClient, error) {
+	stream, err := c.cc.NewStream(ctx, &_Msg_serviceDesc.Streams[0], "/akash.inventory.v1.Msg/QueryNode", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &msgQueryNodeClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type Msg_QueryNodeClient interface {
+	Recv() (*Node, error)
+	grpc.ClientStream
+}
+
+type msgQueryNodeClient struct {
+	grpc.ClientStream
+}
+
+func (x *msgQueryNodeClient) Recv() (*Node, error) {
+	m := new(Node)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// MsgServer is the server API for Msg service.
+type MsgServer interface {
+	// QueryNode defines a method to query an Akash Provider worker node specs
+	QueryNode(*VoidNoParam, Msg_QueryNodeServer) error
+}
+
+// UnimplementedMsgServer can be embedded to have forward compatible implementations.
+type UnimplementedMsgServer struct {
+}
+
+func (*UnimplementedMsgServer) QueryNode(req *VoidNoParam, srv Msg_QueryNodeServer) error {
+	return status.Errorf(codes.Unimplemented, "method QueryNode not implemented")
+}
+
+func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
+	s.RegisterService(&_Msg_serviceDesc, srv)
+}
+
+func _Msg_QueryNode_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(VoidNoParam)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(MsgServer).QueryNode(m, &msgQueryNodeServer{stream})
+}
+
+type Msg_QueryNodeServer interface {
+	Send(*Node) error
+	grpc.ServerStream
+}
+
+type msgQueryNodeServer struct {
+	grpc.ServerStream
+}
+
+func (x *msgQueryNodeServer) Send(m *Node) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _Msg_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "akash.inventory.v1.Msg",
+	HandlerType: (*MsgServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "QueryNode",
+			Handler:       _Msg_QueryNode_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "akash/inventory/v1/service.proto",
+}
+
+func (m *VoidNoParam) 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 *VoidNoParam) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *VoidNoParam) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintService(dAtA []byte, offset int, v uint64) int {
+	offset -= sovService(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *VoidNoParam) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func sovService(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozService(x uint64) (n int) {
+	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *VoidNoParam) 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 ErrIntOverflowService
+			}
+			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: voidNoParam: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: voidNoParam: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipService(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthService
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipService(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowService
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowService
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowService
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthService
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupService
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthService
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthService        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowService          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupService = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/go/inventory/v1/storage.pb.go b/go/inventory/v1/storage.pb.go
index 9c73e388..d5d2d379 100644
--- a/go/inventory/v1/storage.pb.go
+++ b/go/inventory/v1/storage.pb.go
@@ -6,7 +6,7 @@ package v1
 import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -21,7 +21,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type StorageInfo struct {
 	Vendor   string `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor" yaml:"vendor"`
@@ -151,34 +151,34 @@ func init() {
 func init() { proto.RegisterFile("akash/inventory/v1/storage.proto", fileDescriptor_98ef685b221b1af7) }
 
 var fileDescriptor_98ef685b221b1af7 = []byte{
-	// 419 bytes of a gzipped FileDescriptorProto
+	// 423 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0xb1, 0x8e, 0xd3, 0x40,
 	0x10, 0x8d, 0x4d, 0x2e, 0xe4, 0x36, 0x20, 0xa4, 0x15, 0x45, 0xb8, 0xc2, 0x13, 0xad, 0x74, 0x12,
-	0x08, 0x61, 0xeb, 0x42, 0x83, 0x90, 0x68, 0x72, 0x05, 0x8a, 0x84, 0x14, 0x30, 0x88, 0x82, 0x6e,
-	0xcf, 0x38, 0xbe, 0xd5, 0xdd, 0xed, 0x84, 0xb5, 0x13, 0x94, 0xbf, 0xe0, 0xb3, 0x10, 0xd5, 0x95,
-	0x54, 0x2b, 0xb4, 0xe9, 0x5c, 0xba, 0xa4, 0x42, 0xde, 0xdd, 0x33, 0xa0, 0x4b, 0xb7, 0xf3, 0xde,
-	0xbc, 0x79, 0x33, 0xb3, 0x43, 0x26, 0xfc, 0x82, 0x97, 0xe7, 0x89, 0x90, 0x9b, 0x5c, 0x56, 0xa8,
+	0x08, 0x61, 0xeb, 0x42, 0x83, 0x90, 0x68, 0x72, 0x05, 0x4a, 0x95, 0xc3, 0x20, 0x0a, 0xba, 0x3d,
+	0xe3, 0xf8, 0x56, 0x77, 0xb7, 0x13, 0xd6, 0x4e, 0x50, 0xfe, 0x82, 0x92, 0x4f, 0x42, 0x54, 0x57,
+	0x52, 0xad, 0xd0, 0xa6, 0x73, 0xe9, 0x92, 0x0a, 0x79, 0x77, 0xcf, 0x80, 0x48, 0xb7, 0xf3, 0xde,
+	0xbc, 0x79, 0x33, 0xb3, 0x43, 0x26, 0xfc, 0x92, 0x97, 0x17, 0x89, 0x90, 0x9b, 0x5c, 0x56, 0xa8,
 	0xb6, 0xc9, 0xe6, 0x24, 0x29, 0x2b, 0x54, 0xbc, 0xc8, 0xe3, 0x95, 0xc2, 0x0a, 0x29, 0xb5, 0x19,
 	0x71, 0x97, 0x11, 0x6f, 0x4e, 0x8e, 0x1e, 0x16, 0x58, 0xa0, 0xa5, 0x93, 0xf6, 0xe5, 0x32, 0x8f,
-	0x8e, 0xf7, 0xd4, 0x52, 0x79, 0x89, 0x6b, 0x95, 0xe5, 0x2b, 0x2e, 0x94, 0x4b, 0x63, 0xbf, 0x03,
-	0x32, 0x7a, 0xef, 0x2c, 0xe6, 0x72, 0x89, 0xf4, 0x15, 0x19, 0x6c, 0x72, 0xf9, 0x19, 0xd5, 0x38,
-	0x98, 0x04, 0x8f, 0x0f, 0x67, 0xc7, 0x46, 0xc3, 0xe0, 0xa3, 0x45, 0x6a, 0x0d, 0x9e, 0x6b, 0x34,
-	0xdc, 0xdf, 0xf2, 0xab, 0xcb, 0x97, 0xcc, 0xc5, 0x2c, 0xf5, 0x04, 0x7d, 0x41, 0x0e, 0xb2, 0x4b,
+	0x8e, 0xf7, 0xd4, 0x52, 0x79, 0x89, 0x6b, 0x95, 0xe5, 0x2b, 0x2e, 0x94, 0x4b, 0x63, 0xbf, 0x02,
+	0x32, 0x7a, 0xeb, 0x2c, 0xe6, 0x72, 0x89, 0xf4, 0x15, 0x19, 0x6c, 0x72, 0xf9, 0x11, 0xd5, 0x38,
+	0x98, 0x04, 0x8f, 0x0f, 0x67, 0xc7, 0x46, 0xc3, 0xe0, 0xbd, 0x45, 0x6a, 0x0d, 0x9e, 0x6b, 0x34,
+	0xdc, 0xdf, 0xf2, 0xeb, 0xab, 0x97, 0xcc, 0xc5, 0x2c, 0xf5, 0x04, 0x7d, 0x41, 0x0e, 0xb2, 0x2b,
 	0x5e, 0x96, 0xe3, 0xd0, 0xaa, 0x99, 0xd1, 0x70, 0x70, 0xda, 0x02, 0xb5, 0x06, 0xc7, 0x34, 0x1a,
 	0xee, 0x39, 0xad, 0x0d, 0x59, 0xea, 0x60, 0xfa, 0x9a, 0x0c, 0x33, 0xbe, 0xe2, 0x99, 0xa8, 0xb6,
 	0xe3, 0x3b, 0x56, 0xfc, 0xd4, 0x68, 0x18, 0x9e, 0x7a, 0xac, 0xd6, 0xd0, 0xf1, 0x8d, 0x86, 0x07,
 	0xbe, 0x84, 0x47, 0x58, 0xda, 0x91, 0xf4, 0x09, 0x09, 0xe7, 0x8b, 0x71, 0xdf, 0x96, 0x78, 0x64,
 	0x34, 0x84, 0xf3, 0x45, 0xad, 0x21, 0x14, 0xd8, 0x68, 0x38, 0x74, 0x32, 0x81, 0x2c, 0x0d, 0xe7,
-	0x0b, 0xf6, 0x23, 0x20, 0x77, 0xfd, 0xf0, 0x54, 0x90, 0xe1, 0x97, 0x35, 0x97, 0x55, 0xeb, 0xdf,
-	0x8e, 0x3e, 0x9a, 0x4e, 0xe2, 0xdb, 0xcb, 0x8e, 0x53, 0xbf, 0xc2, 0xb7, 0x5c, 0x28, 0xd7, 0xe1,
-	0x3b, 0xaf, 0x6a, 0x3b, 0xbc, 0xa9, 0xf0, 0xb7, 0xc3, 0x1b, 0x84, 0xa5, 0x1d, 0x49, 0x3f, 0x90,
-	0xbe, 0x90, 0x4b, 0xb4, 0x3b, 0x1a, 0x4d, 0x61, 0x9f, 0xcd, 0x3f, 0x5f, 0x32, 0x03, 0xa3, 0xa1,
+	0x0b, 0xf6, 0x3d, 0x20, 0x77, 0xfd, 0xf0, 0x54, 0x90, 0xe1, 0xa7, 0x35, 0x97, 0x55, 0xeb, 0xdf,
+	0x8e, 0x3e, 0x9a, 0x4e, 0xe2, 0xff, 0x97, 0x1d, 0xa7, 0x7e, 0x85, 0x67, 0x5c, 0x28, 0xd7, 0xe1,
+	0x1b, 0xaf, 0x6a, 0x3b, 0xbc, 0xad, 0xf0, 0xa7, 0xc3, 0x5b, 0x84, 0xa5, 0x1d, 0x49, 0xdf, 0x91,
+	0xbe, 0x90, 0x4b, 0xb4, 0x3b, 0x1a, 0x4d, 0x61, 0x9f, 0xcd, 0x5f, 0x5f, 0x32, 0x03, 0xa3, 0xa1,
 	0xdf, 0xbe, 0x6a, 0x0d, 0x56, 0xd8, 0x68, 0x18, 0xf9, 0x41, 0xe4, 0x12, 0x59, 0x6a, 0xc1, 0xd9,
-	0x9b, 0xef, 0x26, 0x0a, 0xae, 0x4d, 0x14, 0xfc, 0x32, 0x51, 0xf0, 0x6d, 0x17, 0xf5, 0xae, 0x77,
-	0x51, 0xef, 0xe7, 0x2e, 0xea, 0x7d, 0x9a, 0x16, 0xa2, 0x3a, 0x5f, 0x9f, 0xc5, 0x19, 0x5e, 0x25,
-	0xd6, 0xeb, 0x99, 0xcc, 0xab, 0xaf, 0xa8, 0x2e, 0x7c, 0xc4, 0x57, 0x22, 0x29, 0xf0, 0xbf, 0x53,
-	0x39, 0x1b, 0xd8, 0xf3, 0x78, 0xfe, 0x27, 0x00, 0x00, 0xff, 0xff, 0xba, 0x35, 0x4e, 0x23, 0x93,
-	0x02, 0x00, 0x00,
+	0xd9, 0x37, 0x13, 0x05, 0x37, 0x26, 0x0a, 0x7e, 0x9a, 0x28, 0xf8, 0xb2, 0x8b, 0x7a, 0x5f, 0x77,
+	0x51, 0xef, 0x66, 0x17, 0xf5, 0x7e, 0xec, 0xa2, 0xde, 0x87, 0x69, 0x21, 0xaa, 0x8b, 0xf5, 0x79,
+	0x9c, 0xe1, 0x75, 0x62, 0xfd, 0x9e, 0xc9, 0xbc, 0xfa, 0x8c, 0xea, 0xd2, 0x47, 0x7c, 0x25, 0x92,
+	0x02, 0xff, 0x39, 0x97, 0xf3, 0x81, 0x3d, 0x91, 0xe7, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x21,
+	0xf6, 0x10, 0xfe, 0x97, 0x02, 0x00, 0x00,
 }
 
 func (m *StorageInfo) Marshal() (dAtA []byte, err error) {
diff --git a/proto/provider/akash/inventory/v1/cluster.proto b/proto/provider/akash/inventory/v1/cluster.proto
index 8c67be03..e4091e64 100644
--- a/proto/provider/akash/inventory/v1/cluster.proto
+++ b/proto/provider/akash/inventory/v1/cluster.proto
@@ -14,7 +14,6 @@ message Cluster {
 
   repeated Node nodes = 1 [
     (gogoproto.nullable) = false,
-    (gogoproto.castrepeated) = "Nodes",
     (gogoproto.customname)   = "Nodes",
     (gogoproto.jsontag)      = "nodes",
     (gogoproto.moretags)     = "yaml:\"nodes\""
@@ -22,7 +21,6 @@ message Cluster {
 
   repeated Storage storage = 2 [
     (gogoproto.nullable)     = false,
-    (gogoproto.casttype)     = "ClusterStorage",
     (gogoproto.customname)   = "Storage",
     (gogoproto.jsontag)      = "storage",
     (gogoproto.moretags)     = "yaml:\"storage\""
diff --git a/proto/provider/akash/inventory/v1/cpu.proto b/proto/provider/akash/inventory/v1/cpu.proto
index 9d9b44ad..2807d4c4 100644
--- a/proto/provider/akash/inventory/v1/cpu.proto
+++ b/proto/provider/akash/inventory/v1/cpu.proto
@@ -6,6 +6,7 @@ import "gogoproto/gogo.proto";
 import "akash/inventory/v1/resourcepair.proto";
 
 option go_package = "github.com/akash-network/akash-api/go/inventory/v1";
+option (gogoproto.gogoproto_import) = false;
 
 message CPUInfo {
   string id = 1 [
diff --git a/proto/provider/akash/inventory/v1/gpu.proto b/proto/provider/akash/inventory/v1/gpu.proto
index 70ae4730..8e377d71 100644
--- a/proto/provider/akash/inventory/v1/gpu.proto
+++ b/proto/provider/akash/inventory/v1/gpu.proto
@@ -7,6 +7,7 @@ import "gogoproto/gogo.proto";
 import "akash/inventory/v1/resourcepair.proto";
 
 option go_package = "github.com/akash-network/akash-api/go/inventory/v1";
+option (gogoproto.gogoproto_import) = false;
 
 message GPUInfo {
   string vendor = 1 [
diff --git a/proto/provider/akash/inventory/v1/memory.proto b/proto/provider/akash/inventory/v1/memory.proto
index 40b775e2..ecb8b3ce 100644
--- a/proto/provider/akash/inventory/v1/memory.proto
+++ b/proto/provider/akash/inventory/v1/memory.proto
@@ -7,6 +7,7 @@ import "gogoproto/gogo.proto";
 import "akash/inventory/v1/resourcepair.proto";
 
 option go_package = "github.com/akash-network/akash-api/go/inventory/v1";
+option (gogoproto.gogoproto_import) = false;
 
 message MemoryInfo {
   string vendor = 1 [
@@ -19,10 +20,10 @@ message MemoryInfo {
     (gogoproto.jsontag)      = "type",
     (gogoproto.moretags)     = "yaml:\"type\""
   ];
-  string size = 3 [
-    (gogoproto.customname)   = "Size",
-    (gogoproto.jsontag)      = "size",
-    (gogoproto.moretags)     = "yaml:\"size\""
+  string totalsize = 3 [
+    (gogoproto.customname)   = "TotalSize",
+    (gogoproto.jsontag)      = "totalsize",
+    (gogoproto.moretags)     = "yaml:\"totalsize\""
   ];
   string speed = 4 [
     (gogoproto.customname)   = "Speed",
@@ -43,4 +44,4 @@ message Memory {
     (gogoproto.jsontag)      = "info",
     (gogoproto.moretags)     = "yaml:\"info\""
   ];
-}
+}
\ No newline at end of file
diff --git a/proto/provider/akash/inventory/v1/node.proto b/proto/provider/akash/inventory/v1/node.proto
index 7929751c..bc5c4afa 100644
--- a/proto/provider/akash/inventory/v1/node.proto
+++ b/proto/provider/akash/inventory/v1/node.proto
@@ -9,6 +9,7 @@ import "akash/inventory/v1/memory.proto";
 
 
 option go_package = "github.com/akash-network/akash-api/go/inventory/v1";
+option (gogoproto.gogoproto_import) = false;
 
 message Node {
   CPU cpu = 1 [
diff --git a/proto/provider/akash/inventory/v1/resourcepair.proto b/proto/provider/akash/inventory/v1/resourcepair.proto
index e9895268..5aa4987b 100644
--- a/proto/provider/akash/inventory/v1/resourcepair.proto
+++ b/proto/provider/akash/inventory/v1/resourcepair.proto
@@ -7,6 +7,7 @@ import "gogoproto/gogo.proto";
 import "k8s.io/apimachinery/pkg/api/resource/generated.proto";
 
 option go_package = "github.com/akash-network/akash-api/go/inventory/v1";
+option (gogoproto.gogoproto_import) = false;
 
 message ResourcePair {
   option (gogoproto.equal) = false;
@@ -24,8 +25,7 @@ message ResourcePair {
     (gogoproto.moretags)   = "yaml:\"allocated\""
   ];
   repeated akash.base.v1beta3.Attribute attributes = 3 [
-    (gogoproto.nullable)     = true,
-    (gogoproto.castrepeated) = "github.com/akash-network/akash-api/go/node/types/v1beta3.Attributes",
+    (gogoproto.nullable)     = false,
     (gogoproto.jsontag)      = "attributes,omitempty",
     (gogoproto.moretags)     = "yaml:\"attributes,omitempty\""
   ];
diff --git a/proto/provider/akash/inventory/v1/service.proto b/proto/provider/akash/inventory/v1/service.proto
new file mode 100644
index 00000000..42658369
--- /dev/null
+++ b/proto/provider/akash/inventory/v1/service.proto
@@ -0,0 +1,16 @@
+syntax = "proto3";
+package akash.inventory.v1;
+
+import "akash/inventory/v1/node.proto";
+
+
+option go_package = "github.com/akash-network/akash-api/go/inventory/v1";
+
+message voidNoParam {}
+
+// Msg defines the deployment Msg service.
+service Msg {
+  // QueryNode defines a method to query an Akash Provider worker node specs
+  rpc QueryNode(voidNoParam) returns (stream Node);
+
+}
\ No newline at end of file
diff --git a/proto/provider/akash/inventory/v1/storage.proto b/proto/provider/akash/inventory/v1/storage.proto
index 19af668f..4d5fba95 100644
--- a/proto/provider/akash/inventory/v1/storage.proto
+++ b/proto/provider/akash/inventory/v1/storage.proto
@@ -7,6 +7,7 @@ import "gogoproto/gogo.proto";
 import "akash/inventory/v1/resourcepair.proto";
 
 option go_package = "github.com/akash-network/akash-api/go/inventory/v1";
+option (gogoproto.gogoproto_import) = false;
 
 message StorageInfo {
     string vendor = 1 [