diff --git a/acl/convert.go b/acl/convert.go
index c5768ad..f5de743 100644
--- a/acl/convert.go
+++ b/acl/convert.go
@@ -187,28 +187,26 @@ func (f *HeaderFilter) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func HeaderFiltersToGRPC(fs []HeaderFilter) (res []*acl.EACLRecord_Filter) {
+func HeaderFiltersToGRPC(fs []HeaderFilter) (res []acl.EACLRecord_Filter) {
 	if fs != nil {
-		res = make([]*acl.EACLRecord_Filter, 0, len(fs))
+		res = make([]acl.EACLRecord_Filter, 0, len(fs))
 
 		for i := range fs {
-			res = append(res, fs[i].ToGRPCMessage().(*acl.EACLRecord_Filter))
+			res = append(res, *fs[i].ToGRPCMessage().(*acl.EACLRecord_Filter))
 		}
 	}
 
 	return
 }
 
-func HeaderFiltersFromGRPC(fs []*acl.EACLRecord_Filter) (res []HeaderFilter, err error) {
+func HeaderFiltersFromGRPC(fs []acl.EACLRecord_Filter) (res []HeaderFilter, err error) {
 	if fs != nil {
 		res = make([]HeaderFilter, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
-				err = res[i].FromGRPCMessage(fs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -241,28 +239,26 @@ func (t *Target) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func TargetsToGRPC(ts []Target) (res []*acl.EACLRecord_Target) {
+func TargetsToGRPC(ts []Target) (res []acl.EACLRecord_Target) {
 	if ts != nil {
-		res = make([]*acl.EACLRecord_Target, 0, len(ts))
+		res = make([]acl.EACLRecord_Target, 0, len(ts))
 
 		for i := range ts {
-			res = append(res, ts[i].ToGRPCMessage().(*acl.EACLRecord_Target))
+			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord_Target))
 		}
 	}
 
 	return
 }
 
-func TargetsFromGRPC(fs []*acl.EACLRecord_Target) (res []Target, err error) {
+func TargetsFromGRPC(fs []acl.EACLRecord_Target) (res []Target, err error) {
 	if fs != nil {
 		res = make([]Target, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
-				err = res[i].FromGRPCMessage(fs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -309,28 +305,26 @@ func (r *Record) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func RecordsToGRPC(ts []Record) (res []*acl.EACLRecord) {
+func RecordsToGRPC(ts []Record) (res []acl.EACLRecord) {
 	if ts != nil {
-		res = make([]*acl.EACLRecord, 0, len(ts))
+		res = make([]acl.EACLRecord, 0, len(ts))
 
 		for i := range ts {
-			res = append(res, ts[i].ToGRPCMessage().(*acl.EACLRecord))
+			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord))
 		}
 	}
 
 	return
 }
 
-func RecordsFromGRPC(fs []*acl.EACLRecord) (res []Record, err error) {
+func RecordsFromGRPC(fs []acl.EACLRecord) (res []Record, err error) {
 	if fs != nil {
 		res = make([]Record, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
-				err = res[i].FromGRPCMessage(fs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -429,9 +423,9 @@ func (c *APEOverride) ToGRPCMessage() grpc.Message {
 		m.SetTarget(c.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
 
 		if len(c.chains) > 0 {
-			apeChains := make([]*apeGRPC.Chain, len(c.chains))
+			apeChains := make([]apeGRPC.Chain, len(c.chains))
 			for i := range c.chains {
-				apeChains[i] = c.chains[i].ToGRPCMessage().(*apeGRPC.Chain)
+				apeChains[i] = *c.chains[i].ToGRPCMessage().(*apeGRPC.Chain)
 			}
 			m.SetChains(apeChains)
 		}
@@ -459,7 +453,7 @@ func (c *APEOverride) FromGRPCMessage(m grpc.Message) error {
 		c.chains = make([]*ape.Chain, len(apeChains))
 		for i := range apeChains {
 			c.chains[i] = new(ape.Chain)
-			if err := c.chains[i].FromGRPCMessage(apeChains[i]); err != nil {
+			if err := c.chains[i].FromGRPCMessage(&apeChains[i]); err != nil {
 				return err
 			}
 		}
diff --git a/acl/grpc/types_frostfs.pb.go b/acl/grpc/types_frostfs.pb.go
index 931f3b3..2b116bd 100644
--- a/acl/grpc/types_frostfs.pb.go
+++ b/acl/grpc/types_frostfs.pb.go
@@ -657,10 +657,10 @@ func (x *EACLRecord_Target) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type EACLRecord struct {
-	Operation Operation            `json:"operation"`
-	Action    Action               `json:"action"`
-	Filters   []*EACLRecord_Filter `json:"filters"`
-	Targets   []*EACLRecord_Target `json:"targets"`
+	Operation Operation           `json:"operation"`
+	Action    Action              `json:"action"`
+	Filters   []EACLRecord_Filter `json:"filters"`
+	Targets   []EACLRecord_Target `json:"targets"`
 }
 
 var (
@@ -680,10 +680,10 @@ func (x *EACLRecord) StableSize() (size int) {
 	size += proto.EnumSize(1, int32(x.Operation))
 	size += proto.EnumSize(2, int32(x.Action))
 	for i := range x.Filters {
-		size += proto.NestedStructureSize(3, x.Filters[i])
+		size += proto.NestedStructureSizeUnchecked(3, &x.Filters[i])
 	}
 	for i := range x.Targets {
-		size += proto.NestedStructureSize(4, x.Targets[i])
+		size += proto.NestedStructureSizeUnchecked(4, &x.Targets[i])
 	}
 	return size
 }
@@ -708,14 +708,10 @@ func (x *EACLRecord) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendInt32(2, int32(x.Action))
 	}
 	for i := range x.Filters {
-		if x.Filters[i] != nil {
-			x.Filters[i].EmitProtobuf(mm.AppendMessage(3))
-		}
+		x.Filters[i].EmitProtobuf(mm.AppendMessage(3))
 	}
 	for i := range x.Targets {
-		if x.Targets[i] != nil {
-			x.Targets[i].EmitProtobuf(mm.AppendMessage(4))
-		}
+		x.Targets[i].EmitProtobuf(mm.AppendMessage(4))
 	}
 }
 
@@ -745,8 +741,8 @@ func (x *EACLRecord) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Filters")
 			}
-			x.Filters = append(x.Filters, new(EACLRecord_Filter))
-			ff := x.Filters[len(x.Filters)-1]
+			x.Filters = append(x.Filters, EACLRecord_Filter{})
+			ff := &x.Filters[len(x.Filters)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -755,8 +751,8 @@ func (x *EACLRecord) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Targets")
 			}
-			x.Targets = append(x.Targets, new(EACLRecord_Target))
-			ff := x.Targets[len(x.Targets)-1]
+			x.Targets = append(x.Targets, EACLRecord_Target{})
+			ff := &x.Targets[len(x.Targets)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -782,22 +778,22 @@ func (x *EACLRecord) GetAction() Action {
 func (x *EACLRecord) SetAction(v Action) {
 	x.Action = v
 }
-func (x *EACLRecord) GetFilters() []*EACLRecord_Filter {
+func (x *EACLRecord) GetFilters() []EACLRecord_Filter {
 	if x != nil {
 		return x.Filters
 	}
 	return nil
 }
-func (x *EACLRecord) SetFilters(v []*EACLRecord_Filter) {
+func (x *EACLRecord) SetFilters(v []EACLRecord_Filter) {
 	x.Filters = v
 }
-func (x *EACLRecord) GetTargets() []*EACLRecord_Target {
+func (x *EACLRecord) GetTargets() []EACLRecord_Target {
 	if x != nil {
 		return x.Targets
 	}
 	return nil
 }
-func (x *EACLRecord) SetTargets(v []*EACLRecord_Target) {
+func (x *EACLRecord) SetTargets(v []EACLRecord_Target) {
 	x.Targets = v
 }
 
@@ -921,11 +917,11 @@ func (x *EACLRecord) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "filters":
 			{
-				var f *EACLRecord_Filter
-				var list []*EACLRecord_Filter
+				var f EACLRecord_Filter
+				var list []EACLRecord_Filter
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(EACLRecord_Filter)
+					f = EACLRecord_Filter{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -935,11 +931,11 @@ func (x *EACLRecord) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "targets":
 			{
-				var f *EACLRecord_Target
-				var list []*EACLRecord_Target
+				var f EACLRecord_Target
+				var list []EACLRecord_Target
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(EACLRecord_Target)
+					f = EACLRecord_Target{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -959,7 +955,7 @@ func (x *EACLRecord) UnmarshalEasyJSON(in *jlexer.Lexer) {
 type EACLTable struct {
 	Version     *grpc.Version     `json:"version"`
 	ContainerId *grpc.ContainerID `json:"containerID"`
-	Records     []*EACLRecord     `json:"records"`
+	Records     []EACLRecord      `json:"records"`
 }
 
 var (
@@ -979,7 +975,7 @@ func (x *EACLTable) StableSize() (size int) {
 	size += proto.NestedStructureSize(1, x.Version)
 	size += proto.NestedStructureSize(2, x.ContainerId)
 	for i := range x.Records {
-		size += proto.NestedStructureSize(3, x.Records[i])
+		size += proto.NestedStructureSizeUnchecked(3, &x.Records[i])
 	}
 	return size
 }
@@ -1004,9 +1000,7 @@ func (x *EACLTable) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		x.ContainerId.EmitProtobuf(mm.AppendMessage(2))
 	}
 	for i := range x.Records {
-		if x.Records[i] != nil {
-			x.Records[i].EmitProtobuf(mm.AppendMessage(3))
-		}
+		x.Records[i].EmitProtobuf(mm.AppendMessage(3))
 	}
 }
 
@@ -1042,8 +1036,8 @@ func (x *EACLTable) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Records")
 			}
-			x.Records = append(x.Records, new(EACLRecord))
-			ff := x.Records[len(x.Records)-1]
+			x.Records = append(x.Records, EACLRecord{})
+			ff := &x.Records[len(x.Records)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1069,13 +1063,13 @@ func (x *EACLTable) GetContainerId() *grpc.ContainerID {
 func (x *EACLTable) SetContainerId(v *grpc.ContainerID) {
 	x.ContainerId = v
 }
-func (x *EACLTable) GetRecords() []*EACLRecord {
+func (x *EACLTable) GetRecords() []EACLRecord {
 	if x != nil {
 		return x.Records
 	}
 	return nil
 }
-func (x *EACLTable) SetRecords(v []*EACLRecord) {
+func (x *EACLTable) SetRecords(v []EACLRecord) {
 	x.Records = v
 }
 
@@ -1157,11 +1151,11 @@ func (x *EACLTable) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "records":
 			{
-				var f *EACLRecord
-				var list []*EACLRecord
+				var f EACLRecord
+				var list []EACLRecord
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(EACLRecord)
+					f = EACLRecord{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1371,7 +1365,7 @@ func (x *BearerToken_Body_TokenLifetime) UnmarshalEasyJSON(in *jlexer.Lexer) {
 
 type BearerToken_Body_APEOverride struct {
 	Target *grpc1.ChainTarget `json:"target"`
-	Chains []*grpc1.Chain     `json:"chains"`
+	Chains []grpc1.Chain      `json:"chains"`
 }
 
 var (
@@ -1390,7 +1384,7 @@ func (x *BearerToken_Body_APEOverride) StableSize() (size int) {
 	}
 	size += proto.NestedStructureSize(1, x.Target)
 	for i := range x.Chains {
-		size += proto.NestedStructureSize(2, x.Chains[i])
+		size += proto.NestedStructureSizeUnchecked(2, &x.Chains[i])
 	}
 	return size
 }
@@ -1412,9 +1406,7 @@ func (x *BearerToken_Body_APEOverride) EmitProtobuf(mm *easyproto.MessageMarshal
 		x.Target.EmitProtobuf(mm.AppendMessage(1))
 	}
 	for i := range x.Chains {
-		if x.Chains[i] != nil {
-			x.Chains[i].EmitProtobuf(mm.AppendMessage(2))
-		}
+		x.Chains[i].EmitProtobuf(mm.AppendMessage(2))
 	}
 }
 
@@ -1441,8 +1433,8 @@ func (x *BearerToken_Body_APEOverride) UnmarshalProtobuf(src []byte) (err error)
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Chains")
 			}
-			x.Chains = append(x.Chains, new(grpc1.Chain))
-			ff := x.Chains[len(x.Chains)-1]
+			x.Chains = append(x.Chains, grpc1.Chain{})
+			ff := &x.Chains[len(x.Chains)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1459,13 +1451,13 @@ func (x *BearerToken_Body_APEOverride) GetTarget() *grpc1.ChainTarget {
 func (x *BearerToken_Body_APEOverride) SetTarget(v *grpc1.ChainTarget) {
 	x.Target = v
 }
-func (x *BearerToken_Body_APEOverride) GetChains() []*grpc1.Chain {
+func (x *BearerToken_Body_APEOverride) GetChains() []grpc1.Chain {
 	if x != nil {
 		return x.Chains
 	}
 	return nil
 }
-func (x *BearerToken_Body_APEOverride) SetChains(v []*grpc1.Chain) {
+func (x *BearerToken_Body_APEOverride) SetChains(v []grpc1.Chain) {
 	x.Chains = v
 }
 
@@ -1535,11 +1527,11 @@ func (x *BearerToken_Body_APEOverride) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "chains":
 			{
-				var f *grpc1.Chain
-				var list []*grpc1.Chain
+				var f grpc1.Chain
+				var list []grpc1.Chain
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc1.Chain)
+					f = grpc1.Chain{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/apemanager/convert.go b/apemanager/convert.go
index fdc5132..5677b25 100644
--- a/apemanager/convert.go
+++ b/apemanager/convert.go
@@ -296,9 +296,9 @@ func (respBody *ListChainsResponseBody) ToGRPCMessage() grpc.Message {
 	if respBody != nil {
 		respBodygrpc = new(apemanager.ListChainsResponse_Body)
 
-		chainsgrpc := make([]*apeGRPC.Chain, 0, len(respBody.GetChains()))
+		chainsgrpc := make([]apeGRPC.Chain, 0, len(respBody.GetChains()))
 		for _, chain := range respBody.GetChains() {
-			chainsgrpc = append(chainsgrpc, chain.ToGRPCMessage().(*apeGRPC.Chain))
+			chainsgrpc = append(chainsgrpc, *chain.ToGRPCMessage().(*apeGRPC.Chain))
 		}
 
 		respBodygrpc.SetChains(chainsgrpc)
@@ -317,7 +317,7 @@ func (respBody *ListChainsResponseBody) FromGRPCMessage(m grpc.Message) error {
 
 	for _, chaingrpc := range respBodygrpc.GetChains() {
 		chain := new(ape.Chain)
-		if err := chain.FromGRPCMessage(chaingrpc); err != nil {
+		if err := chain.FromGRPCMessage(&chaingrpc); err != nil {
 			return err
 		}
 		chains = append(chains, chain)
diff --git a/apemanager/grpc/service_frostfs.pb.go b/apemanager/grpc/service_frostfs.pb.go
index c1d28ed..99abeb2 100644
--- a/apemanager/grpc/service_frostfs.pb.go
+++ b/apemanager/grpc/service_frostfs.pb.go
@@ -1810,7 +1810,7 @@ func (x *ListChainsRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type ListChainsResponse_Body struct {
-	Chains []*grpc.Chain `json:"chains"`
+	Chains []grpc.Chain `json:"chains"`
 }
 
 var (
@@ -1828,7 +1828,7 @@ func (x *ListChainsResponse_Body) StableSize() (size int) {
 		return 0
 	}
 	for i := range x.Chains {
-		size += proto.NestedStructureSize(1, x.Chains[i])
+		size += proto.NestedStructureSizeUnchecked(1, &x.Chains[i])
 	}
 	return size
 }
@@ -1847,9 +1847,7 @@ func (x *ListChainsResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		return
 	}
 	for i := range x.Chains {
-		if x.Chains[i] != nil {
-			x.Chains[i].EmitProtobuf(mm.AppendMessage(1))
-		}
+		x.Chains[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 
@@ -1867,8 +1865,8 @@ func (x *ListChainsResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Chains")
 			}
-			x.Chains = append(x.Chains, new(grpc.Chain))
-			ff := x.Chains[len(x.Chains)-1]
+			x.Chains = append(x.Chains, grpc.Chain{})
+			ff := &x.Chains[len(x.Chains)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1876,13 +1874,13 @@ func (x *ListChainsResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
 	}
 	return nil
 }
-func (x *ListChainsResponse_Body) GetChains() []*grpc.Chain {
+func (x *ListChainsResponse_Body) GetChains() []grpc.Chain {
 	if x != nil {
 		return x.Chains
 	}
 	return nil
 }
-func (x *ListChainsResponse_Body) SetChains(v []*grpc.Chain) {
+func (x *ListChainsResponse_Body) SetChains(v []grpc.Chain) {
 	x.Chains = v
 }
 
@@ -1940,11 +1938,11 @@ func (x *ListChainsResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		switch key {
 		case "chains":
 			{
-				var f *grpc.Chain
-				var list []*grpc.Chain
+				var f grpc.Chain
+				var list []grpc.Chain
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc.Chain)
+					f = grpc.Chain{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/container/convert.go b/container/convert.go
index c5f9cd7..b487f40 100644
--- a/container/convert.go
+++ b/container/convert.go
@@ -39,28 +39,26 @@ func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func AttributesToGRPC(xs []Attribute) (res []*container.Container_Attribute) {
+func AttributesToGRPC(xs []Attribute) (res []container.Container_Attribute) {
 	if xs != nil {
-		res = make([]*container.Container_Attribute, 0, len(xs))
+		res = make([]container.Container_Attribute, 0, len(xs))
 
 		for i := range xs {
-			res = append(res, xs[i].ToGRPCMessage().(*container.Container_Attribute))
+			res = append(res, *xs[i].ToGRPCMessage().(*container.Container_Attribute))
 		}
 	}
 
 	return
 }
 
-func AttributesFromGRPC(xs []*container.Container_Attribute) (res []Attribute, err error) {
+func AttributesFromGRPC(xs []container.Container_Attribute) (res []Attribute, err error) {
 	if xs != nil {
 		res = make([]Attribute, len(xs))
 
 		for i := range xs {
-			if xs[i] != nil {
-				err = res[i].FromGRPCMessage(xs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&xs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
diff --git a/container/grpc/service_frostfs.pb.go b/container/grpc/service_frostfs.pb.go
index 514f03b..f38b0de 100644
--- a/container/grpc/service_frostfs.pb.go
+++ b/container/grpc/service_frostfs.pb.go
@@ -2597,7 +2597,7 @@ func (x *ListRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type ListResponse_Body struct {
-	ContainerIds []*grpc.ContainerID `json:"containerIds"`
+	ContainerIds []grpc.ContainerID `json:"containerIds"`
 }
 
 var (
@@ -2615,7 +2615,7 @@ func (x *ListResponse_Body) StableSize() (size int) {
 		return 0
 	}
 	for i := range x.ContainerIds {
-		size += proto.NestedStructureSize(1, x.ContainerIds[i])
+		size += proto.NestedStructureSizeUnchecked(1, &x.ContainerIds[i])
 	}
 	return size
 }
@@ -2634,9 +2634,7 @@ func (x *ListResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		return
 	}
 	for i := range x.ContainerIds {
-		if x.ContainerIds[i] != nil {
-			x.ContainerIds[i].EmitProtobuf(mm.AppendMessage(1))
-		}
+		x.ContainerIds[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 
@@ -2654,8 +2652,8 @@ func (x *ListResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "ContainerIds")
 			}
-			x.ContainerIds = append(x.ContainerIds, new(grpc.ContainerID))
-			ff := x.ContainerIds[len(x.ContainerIds)-1]
+			x.ContainerIds = append(x.ContainerIds, grpc.ContainerID{})
+			ff := &x.ContainerIds[len(x.ContainerIds)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -2663,13 +2661,13 @@ func (x *ListResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
 	}
 	return nil
 }
-func (x *ListResponse_Body) GetContainerIds() []*grpc.ContainerID {
+func (x *ListResponse_Body) GetContainerIds() []grpc.ContainerID {
 	if x != nil {
 		return x.ContainerIds
 	}
 	return nil
 }
-func (x *ListResponse_Body) SetContainerIds(v []*grpc.ContainerID) {
+func (x *ListResponse_Body) SetContainerIds(v []grpc.ContainerID) {
 	x.ContainerIds = v
 }
 
@@ -2727,11 +2725,11 @@ func (x *ListResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		switch key {
 		case "containerIds":
 			{
-				var f *grpc.ContainerID
-				var list []*grpc.ContainerID
+				var f grpc.ContainerID
+				var list []grpc.ContainerID
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc.ContainerID)
+					f = grpc.ContainerID{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/container/grpc/types_frostfs.pb.go b/container/grpc/types_frostfs.pb.go
index dcb9cf4..3010eb0 100644
--- a/container/grpc/types_frostfs.pb.go
+++ b/container/grpc/types_frostfs.pb.go
@@ -180,7 +180,7 @@ type Container struct {
 	OwnerId         *grpc.OwnerID          `json:"ownerID"`
 	Nonce           []byte                 `json:"nonce"`
 	BasicAcl        uint32                 `json:"basicACL"`
-	Attributes      []*Container_Attribute `json:"attributes"`
+	Attributes      []Container_Attribute  `json:"attributes"`
 	PlacementPolicy *grpc1.PlacementPolicy `json:"placementPolicy"`
 }
 
@@ -203,7 +203,7 @@ func (x *Container) StableSize() (size int) {
 	size += proto.BytesSize(3, x.Nonce)
 	size += proto.UInt32Size(4, x.BasicAcl)
 	for i := range x.Attributes {
-		size += proto.NestedStructureSize(5, x.Attributes[i])
+		size += proto.NestedStructureSizeUnchecked(5, &x.Attributes[i])
 	}
 	size += proto.NestedStructureSize(6, x.PlacementPolicy)
 	return size
@@ -235,9 +235,7 @@ func (x *Container) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendUint32(4, x.BasicAcl)
 	}
 	for i := range x.Attributes {
-		if x.Attributes[i] != nil {
-			x.Attributes[i].EmitProtobuf(mm.AppendMessage(5))
-		}
+		x.Attributes[i].EmitProtobuf(mm.AppendMessage(5))
 	}
 	if x.PlacementPolicy != nil {
 		x.PlacementPolicy.EmitProtobuf(mm.AppendMessage(6))
@@ -288,8 +286,8 @@ func (x *Container) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Attributes")
 			}
-			x.Attributes = append(x.Attributes, new(Container_Attribute))
-			ff := x.Attributes[len(x.Attributes)-1]
+			x.Attributes = append(x.Attributes, Container_Attribute{})
+			ff := &x.Attributes[len(x.Attributes)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -342,13 +340,13 @@ func (x *Container) GetBasicAcl() uint32 {
 func (x *Container) SetBasicAcl(v uint32) {
 	x.BasicAcl = v
 }
-func (x *Container) GetAttributes() []*Container_Attribute {
+func (x *Container) GetAttributes() []Container_Attribute {
 	if x != nil {
 		return x.Attributes
 	}
 	return nil
 }
-func (x *Container) SetAttributes(v []*Container_Attribute) {
+func (x *Container) SetAttributes(v []Container_Attribute) {
 	x.Attributes = v
 }
 func (x *Container) GetPlacementPolicy() *grpc1.PlacementPolicy {
@@ -466,11 +464,11 @@ func (x *Container) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "attributes":
 			{
-				var f *Container_Attribute
-				var list []*Container_Attribute
+				var f Container_Attribute
+				var list []Container_Attribute
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Container_Attribute)
+					f = Container_Attribute{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/lock/grpc/types_frostfs.pb.go b/lock/grpc/types_frostfs.pb.go
index 52a1a2d..58be895 100644
--- a/lock/grpc/types_frostfs.pb.go
+++ b/lock/grpc/types_frostfs.pb.go
@@ -15,7 +15,7 @@ import (
 )
 
 type Lock struct {
-	Members []*grpc.ObjectID `json:"members"`
+	Members []grpc.ObjectID `json:"members"`
 }
 
 var (
@@ -33,7 +33,7 @@ func (x *Lock) StableSize() (size int) {
 		return 0
 	}
 	for i := range x.Members {
-		size += proto.NestedStructureSize(1, x.Members[i])
+		size += proto.NestedStructureSizeUnchecked(1, &x.Members[i])
 	}
 	return size
 }
@@ -52,9 +52,7 @@ func (x *Lock) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		return
 	}
 	for i := range x.Members {
-		if x.Members[i] != nil {
-			x.Members[i].EmitProtobuf(mm.AppendMessage(1))
-		}
+		x.Members[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 
@@ -72,8 +70,8 @@ func (x *Lock) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Members")
 			}
-			x.Members = append(x.Members, new(grpc.ObjectID))
-			ff := x.Members[len(x.Members)-1]
+			x.Members = append(x.Members, grpc.ObjectID{})
+			ff := &x.Members[len(x.Members)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -81,13 +79,13 @@ func (x *Lock) UnmarshalProtobuf(src []byte) (err error) {
 	}
 	return nil
 }
-func (x *Lock) GetMembers() []*grpc.ObjectID {
+func (x *Lock) GetMembers() []grpc.ObjectID {
 	if x != nil {
 		return x.Members
 	}
 	return nil
 }
-func (x *Lock) SetMembers(v []*grpc.ObjectID) {
+func (x *Lock) SetMembers(v []grpc.ObjectID) {
 	x.Members = v
 }
 
@@ -145,11 +143,11 @@ func (x *Lock) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		switch key {
 		case "members":
 			{
-				var f *grpc.ObjectID
-				var list []*grpc.ObjectID
+				var f grpc.ObjectID
+				var list []grpc.ObjectID
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc.ObjectID)
+					f = grpc.ObjectID{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/netmap/convert.go b/netmap/convert.go
index fad7380..659b798 100644
--- a/netmap/convert.go
+++ b/netmap/convert.go
@@ -45,28 +45,26 @@ func (f *Filter) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func FiltersToGRPC(fs []Filter) (res []*netmap.Filter) {
+func FiltersToGRPC(fs []Filter) (res []netmap.Filter) {
 	if fs != nil {
-		res = make([]*netmap.Filter, 0, len(fs))
+		res = make([]netmap.Filter, 0, len(fs))
 
 		for i := range fs {
-			res = append(res, fs[i].ToGRPCMessage().(*netmap.Filter))
+			res = append(res, *fs[i].ToGRPCMessage().(*netmap.Filter))
 		}
 	}
 
 	return
 }
 
-func FiltersFromGRPC(fs []*netmap.Filter) (res []Filter, err error) {
+func FiltersFromGRPC(fs []netmap.Filter) (res []Filter, err error) {
 	if fs != nil {
 		res = make([]Filter, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
-				err = res[i].FromGRPCMessage(fs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -105,28 +103,26 @@ func (s *Selector) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func SelectorsToGRPC(ss []Selector) (res []*netmap.Selector) {
+func SelectorsToGRPC(ss []Selector) (res []netmap.Selector) {
 	if ss != nil {
-		res = make([]*netmap.Selector, 0, len(ss))
+		res = make([]netmap.Selector, 0, len(ss))
 
 		for i := range ss {
-			res = append(res, ss[i].ToGRPCMessage().(*netmap.Selector))
+			res = append(res, *ss[i].ToGRPCMessage().(*netmap.Selector))
 		}
 	}
 
 	return
 }
 
-func SelectorsFromGRPC(ss []*netmap.Selector) (res []Selector, err error) {
+func SelectorsFromGRPC(ss []netmap.Selector) (res []Selector, err error) {
 	if ss != nil {
 		res = make([]Selector, len(ss))
 
 		for i := range ss {
-			if ss[i] != nil {
-				err = res[i].FromGRPCMessage(ss[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&ss[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -163,28 +159,26 @@ func (r *Replica) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func ReplicasToGRPC(rs []Replica) (res []*netmap.Replica) {
+func ReplicasToGRPC(rs []Replica) (res []netmap.Replica) {
 	if rs != nil {
-		res = make([]*netmap.Replica, 0, len(rs))
+		res = make([]netmap.Replica, 0, len(rs))
 
 		for i := range rs {
-			res = append(res, rs[i].ToGRPCMessage().(*netmap.Replica))
+			res = append(res, *rs[i].ToGRPCMessage().(*netmap.Replica))
 		}
 	}
 
 	return
 }
 
-func ReplicasFromGRPC(rs []*netmap.Replica) (res []Replica, err error) {
+func ReplicasFromGRPC(rs []netmap.Replica) (res []Replica, err error) {
 	if rs != nil {
 		res = make([]Replica, len(rs))
 
 		for i := range rs {
-			if rs[i] != nil {
-				err = res[i].FromGRPCMessage(rs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&rs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -289,28 +283,26 @@ func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func AttributesToGRPC(as []Attribute) (res []*netmap.NodeInfo_Attribute) {
+func AttributesToGRPC(as []Attribute) (res []netmap.NodeInfo_Attribute) {
 	if as != nil {
-		res = make([]*netmap.NodeInfo_Attribute, 0, len(as))
+		res = make([]netmap.NodeInfo_Attribute, 0, len(as))
 
 		for i := range as {
-			res = append(res, as[i].ToGRPCMessage().(*netmap.NodeInfo_Attribute))
+			res = append(res, *as[i].ToGRPCMessage().(*netmap.NodeInfo_Attribute))
 		}
 	}
 
 	return
 }
 
-func AttributesFromGRPC(as []*netmap.NodeInfo_Attribute) (res []Attribute, err error) {
+func AttributesFromGRPC(as []netmap.NodeInfo_Attribute) (res []Attribute, err error) {
 	if as != nil {
 		res = make([]Attribute, len(as))
 
 		for i := range as {
-			if as[i] != nil {
-				err = res[i].FromGRPCMessage(as[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&as[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -528,13 +520,13 @@ func (x *NetworkConfig) ToGRPCMessage() grpc.Message {
 	if x != nil {
 		m = new(netmap.NetworkConfig)
 
-		var ps []*netmap.NetworkConfig_Parameter
+		var ps []netmap.NetworkConfig_Parameter
 
 		if ln := len(x.ps); ln > 0 {
-			ps = make([]*netmap.NetworkConfig_Parameter, 0, ln)
+			ps = make([]netmap.NetworkConfig_Parameter, 0, ln)
 
 			for i := 0; i < ln; i++ {
-				ps = append(ps, x.ps[i].ToGRPCMessage().(*netmap.NetworkConfig_Parameter))
+				ps = append(ps, *x.ps[i].ToGRPCMessage().(*netmap.NetworkConfig_Parameter))
 			}
 		}
 
@@ -561,10 +553,8 @@ func (x *NetworkConfig) FromGRPCMessage(m grpc.Message) error {
 		ps = make([]NetworkParameter, ln)
 
 		for i := 0; i < ln; i++ {
-			if psV2[i] != nil {
-				if err := ps[i].FromGRPCMessage(psV2[i]); err != nil {
-					return err
-				}
+			if err := ps[i].FromGRPCMessage(&psV2[i]); err != nil {
+				return err
 			}
 		}
 	}
@@ -756,10 +746,10 @@ func (x *NetMap) ToGRPCMessage() grpc.Message {
 		m.SetEpoch(x.epoch)
 
 		if x.nodes != nil {
-			nodes := make([]*netmap.NodeInfo, len(x.nodes))
+			nodes := make([]netmap.NodeInfo, len(x.nodes))
 
 			for i := range x.nodes {
-				nodes[i] = x.nodes[i].ToGRPCMessage().(*netmap.NodeInfo)
+				nodes[i] = *x.nodes[i].ToGRPCMessage().(*netmap.NodeInfo)
 			}
 
 			m.SetNodes(nodes)
@@ -784,7 +774,7 @@ func (x *NetMap) FromGRPCMessage(m grpc.Message) error {
 		x.nodes = make([]NodeInfo, len(nodes))
 
 		for i := range nodes {
-			err = x.nodes[i].FromGRPCMessage(nodes[i])
+			err = x.nodes[i].FromGRPCMessage(&nodes[i])
 			if err != nil {
 				return err
 			}
diff --git a/netmap/grpc/types_frostfs.pb.go b/netmap/grpc/types_frostfs.pb.go
index 6ecf0fa..e7597ea 100644
--- a/netmap/grpc/types_frostfs.pb.go
+++ b/netmap/grpc/types_frostfs.pb.go
@@ -113,7 +113,7 @@ type Filter struct {
 	Key     string    `json:"key"`
 	Op      Operation `json:"op"`
 	Value   string    `json:"value"`
-	Filters []*Filter `json:"filters"`
+	Filters []Filter  `json:"filters"`
 }
 
 var (
@@ -135,7 +135,7 @@ func (x *Filter) StableSize() (size int) {
 	size += proto.EnumSize(3, int32(x.Op))
 	size += proto.StringSize(4, x.Value)
 	for i := range x.Filters {
-		size += proto.NestedStructureSize(5, x.Filters[i])
+		size += proto.NestedStructureSizeUnchecked(5, &x.Filters[i])
 	}
 	return size
 }
@@ -166,9 +166,7 @@ func (x *Filter) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendString(4, x.Value)
 	}
 	for i := range x.Filters {
-		if x.Filters[i] != nil {
-			x.Filters[i].EmitProtobuf(mm.AppendMessage(5))
-		}
+		x.Filters[i].EmitProtobuf(mm.AppendMessage(5))
 	}
 }
 
@@ -210,8 +208,8 @@ func (x *Filter) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Filters")
 			}
-			x.Filters = append(x.Filters, new(Filter))
-			ff := x.Filters[len(x.Filters)-1]
+			x.Filters = append(x.Filters, Filter{})
+			ff := &x.Filters[len(x.Filters)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -255,13 +253,13 @@ func (x *Filter) GetValue() string {
 func (x *Filter) SetValue(v string) {
 	x.Value = v
 }
-func (x *Filter) GetFilters() []*Filter {
+func (x *Filter) GetFilters() []Filter {
 	if x != nil {
 		return x.Filters
 	}
 	return nil
 }
-func (x *Filter) SetFilters(v []*Filter) {
+func (x *Filter) SetFilters(v []Filter) {
 	x.Filters = v
 }
 
@@ -379,11 +377,11 @@ func (x *Filter) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "filters":
 			{
-				var f *Filter
-				var list []*Filter
+				var f Filter
+				var list []Filter
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Filter)
+					f = Filter{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -892,11 +890,11 @@ func (x *Replica) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type PlacementPolicy struct {
-	Replicas              []*Replica  `json:"replicas"`
-	ContainerBackupFactor uint32      `json:"containerBackupFactor"`
-	Selectors             []*Selector `json:"selectors"`
-	Filters               []*Filter   `json:"filters"`
-	Unique                bool        `json:"unique"`
+	Replicas              []Replica  `json:"replicas"`
+	ContainerBackupFactor uint32     `json:"containerBackupFactor"`
+	Selectors             []Selector `json:"selectors"`
+	Filters               []Filter   `json:"filters"`
+	Unique                bool       `json:"unique"`
 }
 
 var (
@@ -914,14 +912,14 @@ func (x *PlacementPolicy) StableSize() (size int) {
 		return 0
 	}
 	for i := range x.Replicas {
-		size += proto.NestedStructureSize(1, x.Replicas[i])
+		size += proto.NestedStructureSizeUnchecked(1, &x.Replicas[i])
 	}
 	size += proto.UInt32Size(2, x.ContainerBackupFactor)
 	for i := range x.Selectors {
-		size += proto.NestedStructureSize(3, x.Selectors[i])
+		size += proto.NestedStructureSizeUnchecked(3, &x.Selectors[i])
 	}
 	for i := range x.Filters {
-		size += proto.NestedStructureSize(4, x.Filters[i])
+		size += proto.NestedStructureSizeUnchecked(4, &x.Filters[i])
 	}
 	size += proto.BoolSize(5, x.Unique)
 	return size
@@ -941,22 +939,16 @@ func (x *PlacementPolicy) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		return
 	}
 	for i := range x.Replicas {
-		if x.Replicas[i] != nil {
-			x.Replicas[i].EmitProtobuf(mm.AppendMessage(1))
-		}
+		x.Replicas[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 	if x.ContainerBackupFactor != 0 {
 		mm.AppendUint32(2, x.ContainerBackupFactor)
 	}
 	for i := range x.Selectors {
-		if x.Selectors[i] != nil {
-			x.Selectors[i].EmitProtobuf(mm.AppendMessage(3))
-		}
+		x.Selectors[i].EmitProtobuf(mm.AppendMessage(3))
 	}
 	for i := range x.Filters {
-		if x.Filters[i] != nil {
-			x.Filters[i].EmitProtobuf(mm.AppendMessage(4))
-		}
+		x.Filters[i].EmitProtobuf(mm.AppendMessage(4))
 	}
 	if x.Unique {
 		mm.AppendBool(5, x.Unique)
@@ -977,8 +969,8 @@ func (x *PlacementPolicy) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Replicas")
 			}
-			x.Replicas = append(x.Replicas, new(Replica))
-			ff := x.Replicas[len(x.Replicas)-1]
+			x.Replicas = append(x.Replicas, Replica{})
+			ff := &x.Replicas[len(x.Replicas)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -993,8 +985,8 @@ func (x *PlacementPolicy) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Selectors")
 			}
-			x.Selectors = append(x.Selectors, new(Selector))
-			ff := x.Selectors[len(x.Selectors)-1]
+			x.Selectors = append(x.Selectors, Selector{})
+			ff := &x.Selectors[len(x.Selectors)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1003,8 +995,8 @@ func (x *PlacementPolicy) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Filters")
 			}
-			x.Filters = append(x.Filters, new(Filter))
-			ff := x.Filters[len(x.Filters)-1]
+			x.Filters = append(x.Filters, Filter{})
+			ff := &x.Filters[len(x.Filters)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1018,13 +1010,13 @@ func (x *PlacementPolicy) UnmarshalProtobuf(src []byte) (err error) {
 	}
 	return nil
 }
-func (x *PlacementPolicy) GetReplicas() []*Replica {
+func (x *PlacementPolicy) GetReplicas() []Replica {
 	if x != nil {
 		return x.Replicas
 	}
 	return nil
 }
-func (x *PlacementPolicy) SetReplicas(v []*Replica) {
+func (x *PlacementPolicy) SetReplicas(v []Replica) {
 	x.Replicas = v
 }
 func (x *PlacementPolicy) GetContainerBackupFactor() uint32 {
@@ -1036,22 +1028,22 @@ func (x *PlacementPolicy) GetContainerBackupFactor() uint32 {
 func (x *PlacementPolicy) SetContainerBackupFactor(v uint32) {
 	x.ContainerBackupFactor = v
 }
-func (x *PlacementPolicy) GetSelectors() []*Selector {
+func (x *PlacementPolicy) GetSelectors() []Selector {
 	if x != nil {
 		return x.Selectors
 	}
 	return nil
 }
-func (x *PlacementPolicy) SetSelectors(v []*Selector) {
+func (x *PlacementPolicy) SetSelectors(v []Selector) {
 	x.Selectors = v
 }
-func (x *PlacementPolicy) GetFilters() []*Filter {
+func (x *PlacementPolicy) GetFilters() []Filter {
 	if x != nil {
 		return x.Filters
 	}
 	return nil
 }
-func (x *PlacementPolicy) SetFilters(v []*Filter) {
+func (x *PlacementPolicy) SetFilters(v []Filter) {
 	x.Filters = v
 }
 func (x *PlacementPolicy) GetUnique() bool {
@@ -1152,11 +1144,11 @@ func (x *PlacementPolicy) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		switch key {
 		case "replicas":
 			{
-				var f *Replica
-				var list []*Replica
+				var f Replica
+				var list []Replica
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Replica)
+					f = Replica{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1172,11 +1164,11 @@ func (x *PlacementPolicy) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "selectors":
 			{
-				var f *Selector
-				var list []*Selector
+				var f Selector
+				var list []Selector
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Selector)
+					f = Selector{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1186,11 +1178,11 @@ func (x *PlacementPolicy) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "filters":
 			{
-				var f *Filter
-				var list []*Filter
+				var f Filter
+				var list []Filter
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Filter)
+					f = Filter{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1457,10 +1449,10 @@ func (x *NodeInfo_Attribute) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type NodeInfo struct {
-	PublicKey  []byte                `json:"publicKey"`
-	Addresses  []string              `json:"addresses"`
-	Attributes []*NodeInfo_Attribute `json:"attributes"`
-	State      NodeInfo_State        `json:"state"`
+	PublicKey  []byte               `json:"publicKey"`
+	Addresses  []string             `json:"addresses"`
+	Attributes []NodeInfo_Attribute `json:"attributes"`
+	State      NodeInfo_State       `json:"state"`
 }
 
 var (
@@ -1480,7 +1472,7 @@ func (x *NodeInfo) StableSize() (size int) {
 	size += proto.BytesSize(1, x.PublicKey)
 	size += proto.RepeatedStringSize(2, x.Addresses)
 	for i := range x.Attributes {
-		size += proto.NestedStructureSize(3, x.Attributes[i])
+		size += proto.NestedStructureSizeUnchecked(3, &x.Attributes[i])
 	}
 	size += proto.EnumSize(4, int32(x.State))
 	return size
@@ -1506,9 +1498,7 @@ func (x *NodeInfo) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendString(2, x.Addresses[j])
 	}
 	for i := range x.Attributes {
-		if x.Attributes[i] != nil {
-			x.Attributes[i].EmitProtobuf(mm.AppendMessage(3))
-		}
+		x.Attributes[i].EmitProtobuf(mm.AppendMessage(3))
 	}
 	if int32(x.State) != 0 {
 		mm.AppendInt32(4, int32(x.State))
@@ -1541,8 +1531,8 @@ func (x *NodeInfo) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Attributes")
 			}
-			x.Attributes = append(x.Attributes, new(NodeInfo_Attribute))
-			ff := x.Attributes[len(x.Attributes)-1]
+			x.Attributes = append(x.Attributes, NodeInfo_Attribute{})
+			ff := &x.Attributes[len(x.Attributes)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1574,13 +1564,13 @@ func (x *NodeInfo) GetAddresses() []string {
 func (x *NodeInfo) SetAddresses(v []string) {
 	x.Addresses = v
 }
-func (x *NodeInfo) GetAttributes() []*NodeInfo_Attribute {
+func (x *NodeInfo) GetAttributes() []NodeInfo_Attribute {
 	if x != nil {
 		return x.Attributes
 	}
 	return nil
 }
-func (x *NodeInfo) SetAttributes(v []*NodeInfo_Attribute) {
+func (x *NodeInfo) SetAttributes(v []NodeInfo_Attribute) {
 	x.Attributes = v
 }
 func (x *NodeInfo) GetState() NodeInfo_State {
@@ -1688,11 +1678,11 @@ func (x *NodeInfo) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "attributes":
 			{
-				var f *NodeInfo_Attribute
-				var list []*NodeInfo_Attribute
+				var f NodeInfo_Attribute
+				var list []NodeInfo_Attribute
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(NodeInfo_Attribute)
+					f = NodeInfo_Attribute{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1732,8 +1722,8 @@ func (x *NodeInfo) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type Netmap struct {
-	Epoch uint64      `json:"epoch"`
-	Nodes []*NodeInfo `json:"nodes"`
+	Epoch uint64     `json:"epoch"`
+	Nodes []NodeInfo `json:"nodes"`
 }
 
 var (
@@ -1752,7 +1742,7 @@ func (x *Netmap) StableSize() (size int) {
 	}
 	size += proto.UInt64Size(1, x.Epoch)
 	for i := range x.Nodes {
-		size += proto.NestedStructureSize(2, x.Nodes[i])
+		size += proto.NestedStructureSizeUnchecked(2, &x.Nodes[i])
 	}
 	return size
 }
@@ -1774,9 +1764,7 @@ func (x *Netmap) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendUint64(1, x.Epoch)
 	}
 	for i := range x.Nodes {
-		if x.Nodes[i] != nil {
-			x.Nodes[i].EmitProtobuf(mm.AppendMessage(2))
-		}
+		x.Nodes[i].EmitProtobuf(mm.AppendMessage(2))
 	}
 }
 
@@ -1800,8 +1788,8 @@ func (x *Netmap) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Nodes")
 			}
-			x.Nodes = append(x.Nodes, new(NodeInfo))
-			ff := x.Nodes[len(x.Nodes)-1]
+			x.Nodes = append(x.Nodes, NodeInfo{})
+			ff := &x.Nodes[len(x.Nodes)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1818,13 +1806,13 @@ func (x *Netmap) GetEpoch() uint64 {
 func (x *Netmap) SetEpoch(v uint64) {
 	x.Epoch = v
 }
-func (x *Netmap) GetNodes() []*NodeInfo {
+func (x *Netmap) GetNodes() []NodeInfo {
 	if x != nil {
 		return x.Nodes
 	}
 	return nil
 }
-func (x *Netmap) SetNodes(v []*NodeInfo) {
+func (x *Netmap) SetNodes(v []NodeInfo) {
 	x.Nodes = v
 }
 
@@ -1893,11 +1881,11 @@ func (x *Netmap) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "nodes":
 			{
-				var f *NodeInfo
-				var list []*NodeInfo
+				var f NodeInfo
+				var list []NodeInfo
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(NodeInfo)
+					f = NodeInfo{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -2075,7 +2063,7 @@ func (x *NetworkConfig_Parameter) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type NetworkConfig struct {
-	Parameters []*NetworkConfig_Parameter `json:"parameters"`
+	Parameters []NetworkConfig_Parameter `json:"parameters"`
 }
 
 var (
@@ -2093,7 +2081,7 @@ func (x *NetworkConfig) StableSize() (size int) {
 		return 0
 	}
 	for i := range x.Parameters {
-		size += proto.NestedStructureSize(1, x.Parameters[i])
+		size += proto.NestedStructureSizeUnchecked(1, &x.Parameters[i])
 	}
 	return size
 }
@@ -2112,9 +2100,7 @@ func (x *NetworkConfig) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		return
 	}
 	for i := range x.Parameters {
-		if x.Parameters[i] != nil {
-			x.Parameters[i].EmitProtobuf(mm.AppendMessage(1))
-		}
+		x.Parameters[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 
@@ -2132,8 +2118,8 @@ func (x *NetworkConfig) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Parameters")
 			}
-			x.Parameters = append(x.Parameters, new(NetworkConfig_Parameter))
-			ff := x.Parameters[len(x.Parameters)-1]
+			x.Parameters = append(x.Parameters, NetworkConfig_Parameter{})
+			ff := &x.Parameters[len(x.Parameters)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -2141,13 +2127,13 @@ func (x *NetworkConfig) UnmarshalProtobuf(src []byte) (err error) {
 	}
 	return nil
 }
-func (x *NetworkConfig) GetParameters() []*NetworkConfig_Parameter {
+func (x *NetworkConfig) GetParameters() []NetworkConfig_Parameter {
 	if x != nil {
 		return x.Parameters
 	}
 	return nil
 }
-func (x *NetworkConfig) SetParameters(v []*NetworkConfig_Parameter) {
+func (x *NetworkConfig) SetParameters(v []NetworkConfig_Parameter) {
 	x.Parameters = v
 }
 
@@ -2205,11 +2191,11 @@ func (x *NetworkConfig) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		switch key {
 		case "parameters":
 			{
-				var f *NetworkConfig_Parameter
-				var list []*NetworkConfig_Parameter
+				var f NetworkConfig_Parameter
+				var list []NetworkConfig_Parameter
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(NetworkConfig_Parameter)
+					f = NetworkConfig_Parameter{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/object/convert.go b/object/convert.go
index e237883..88e6ab7 100644
--- a/object/convert.go
+++ b/object/convert.go
@@ -142,28 +142,26 @@ func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func AttributesToGRPC(xs []Attribute) (res []*object.Header_Attribute) {
+func AttributesToGRPC(xs []Attribute) (res []object.Header_Attribute) {
 	if xs != nil {
-		res = make([]*object.Header_Attribute, 0, len(xs))
+		res = make([]object.Header_Attribute, 0, len(xs))
 
 		for i := range xs {
-			res = append(res, xs[i].ToGRPCMessage().(*object.Header_Attribute))
+			res = append(res, *xs[i].ToGRPCMessage().(*object.Header_Attribute))
 		}
 	}
 
 	return
 }
 
-func AttributesFromGRPC(xs []*object.Header_Attribute) (res []Attribute, err error) {
+func AttributesFromGRPC(xs []object.Header_Attribute) (res []Attribute, err error) {
 	if xs != nil {
 		res = make([]Attribute, len(xs))
 
 		for i := range xs {
-			if xs[i] != nil {
-				err = res[i].FromGRPCMessage(xs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&xs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -683,9 +681,9 @@ func (s *ECInfo) ToGRPCMessage() grpc.Message {
 		m = new(object.ECInfo)
 
 		if s.Chunks != nil {
-			chunks := make([]*object.ECInfo_Chunk, len(s.Chunks))
+			chunks := make([]object.ECInfo_Chunk, len(s.Chunks))
 			for i := range chunks {
-				chunks[i] = s.Chunks[i].ToGRPCMessage().(*object.ECInfo_Chunk)
+				chunks[i] = *s.Chunks[i].ToGRPCMessage().(*object.ECInfo_Chunk)
 			}
 			m.Chunks = chunks
 		}
@@ -706,7 +704,7 @@ func (s *ECInfo) FromGRPCMessage(m grpc.Message) error {
 	} else {
 		s.Chunks = make([]ECChunk, len(chunks))
 		for i := range chunks {
-			if err := s.Chunks[i].FromGRPCMessage(chunks[i]); err != nil {
+			if err := s.Chunks[i].FromGRPCMessage(&chunks[i]); err != nil {
 				return err
 			}
 		}
@@ -1626,28 +1624,26 @@ func (f *SearchFilter) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func SearchFiltersToGRPC(fs []SearchFilter) (res []*object.SearchRequest_Body_Filter) {
+func SearchFiltersToGRPC(fs []SearchFilter) (res []object.SearchRequest_Body_Filter) {
 	if fs != nil {
-		res = make([]*object.SearchRequest_Body_Filter, 0, len(fs))
+		res = make([]object.SearchRequest_Body_Filter, 0, len(fs))
 
 		for i := range fs {
-			res = append(res, fs[i].ToGRPCMessage().(*object.SearchRequest_Body_Filter))
+			res = append(res, *fs[i].ToGRPCMessage().(*object.SearchRequest_Body_Filter))
 		}
 	}
 
 	return
 }
 
-func SearchFiltersFromGRPC(fs []*object.SearchRequest_Body_Filter) (res []SearchFilter, err error) {
+func SearchFiltersFromGRPC(fs []object.SearchRequest_Body_Filter) (res []SearchFilter, err error) {
 	if fs != nil {
 		res = make([]SearchFilter, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
-				err = res[i].FromGRPCMessage(fs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -1827,28 +1823,26 @@ func (r *Range) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func RangesToGRPC(rs []Range) (res []*object.Range) {
+func RangesToGRPC(rs []Range) (res []object.Range) {
 	if rs != nil {
-		res = make([]*object.Range, 0, len(rs))
+		res = make([]object.Range, 0, len(rs))
 
 		for i := range rs {
-			res = append(res, rs[i].ToGRPCMessage().(*object.Range))
+			res = append(res, *rs[i].ToGRPCMessage().(*object.Range))
 		}
 	}
 
 	return
 }
 
-func RangesFromGRPC(rs []*object.Range) (res []Range, err error) {
+func RangesFromGRPC(rs []object.Range) (res []Range, err error) {
 	if rs != nil {
 		res = make([]Range, len(rs))
 
 		for i := range rs {
-			if rs[i] != nil {
-				err = res[i].FromGRPCMessage(rs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&rs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
diff --git a/object/grpc/service_frostfs.pb.go b/object/grpc/service_frostfs.pb.go
index 0bd0111..dea1b5b 100644
--- a/object/grpc/service_frostfs.pb.go
+++ b/object/grpc/service_frostfs.pb.go
@@ -4201,9 +4201,9 @@ func (x *SearchRequest_Body_Filter) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type SearchRequest_Body struct {
-	ContainerId *grpc.ContainerID            `json:"containerId"`
-	Version     uint32                       `json:"version"`
-	Filters     []*SearchRequest_Body_Filter `json:"filters"`
+	ContainerId *grpc.ContainerID           `json:"containerId"`
+	Version     uint32                      `json:"version"`
+	Filters     []SearchRequest_Body_Filter `json:"filters"`
 }
 
 var (
@@ -4223,7 +4223,7 @@ func (x *SearchRequest_Body) StableSize() (size int) {
 	size += proto.NestedStructureSize(1, x.ContainerId)
 	size += proto.UInt32Size(2, x.Version)
 	for i := range x.Filters {
-		size += proto.NestedStructureSize(3, x.Filters[i])
+		size += proto.NestedStructureSizeUnchecked(3, &x.Filters[i])
 	}
 	return size
 }
@@ -4248,9 +4248,7 @@ func (x *SearchRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendUint32(2, x.Version)
 	}
 	for i := range x.Filters {
-		if x.Filters[i] != nil {
-			x.Filters[i].EmitProtobuf(mm.AppendMessage(3))
-		}
+		x.Filters[i].EmitProtobuf(mm.AppendMessage(3))
 	}
 }
 
@@ -4283,8 +4281,8 @@ func (x *SearchRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Filters")
 			}
-			x.Filters = append(x.Filters, new(SearchRequest_Body_Filter))
-			ff := x.Filters[len(x.Filters)-1]
+			x.Filters = append(x.Filters, SearchRequest_Body_Filter{})
+			ff := &x.Filters[len(x.Filters)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -4310,13 +4308,13 @@ func (x *SearchRequest_Body) GetVersion() uint32 {
 func (x *SearchRequest_Body) SetVersion(v uint32) {
 	x.Version = v
 }
-func (x *SearchRequest_Body) GetFilters() []*SearchRequest_Body_Filter {
+func (x *SearchRequest_Body) GetFilters() []SearchRequest_Body_Filter {
 	if x != nil {
 		return x.Filters
 	}
 	return nil
 }
-func (x *SearchRequest_Body) SetFilters(v []*SearchRequest_Body_Filter) {
+func (x *SearchRequest_Body) SetFilters(v []SearchRequest_Body_Filter) {
 	x.Filters = v
 }
 
@@ -4397,11 +4395,11 @@ func (x *SearchRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "filters":
 			{
-				var f *SearchRequest_Body_Filter
-				var list []*SearchRequest_Body_Filter
+				var f SearchRequest_Body_Filter
+				var list []SearchRequest_Body_Filter
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(SearchRequest_Body_Filter)
+					f = SearchRequest_Body_Filter{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -4640,7 +4638,7 @@ func (x *SearchRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type SearchResponse_Body struct {
-	IdList []*grpc.ObjectID `json:"idList"`
+	IdList []grpc.ObjectID `json:"idList"`
 }
 
 var (
@@ -4658,7 +4656,7 @@ func (x *SearchResponse_Body) StableSize() (size int) {
 		return 0
 	}
 	for i := range x.IdList {
-		size += proto.NestedStructureSize(1, x.IdList[i])
+		size += proto.NestedStructureSizeUnchecked(1, &x.IdList[i])
 	}
 	return size
 }
@@ -4677,9 +4675,7 @@ func (x *SearchResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		return
 	}
 	for i := range x.IdList {
-		if x.IdList[i] != nil {
-			x.IdList[i].EmitProtobuf(mm.AppendMessage(1))
-		}
+		x.IdList[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 
@@ -4697,8 +4693,8 @@ func (x *SearchResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "IdList")
 			}
-			x.IdList = append(x.IdList, new(grpc.ObjectID))
-			ff := x.IdList[len(x.IdList)-1]
+			x.IdList = append(x.IdList, grpc.ObjectID{})
+			ff := &x.IdList[len(x.IdList)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -4706,13 +4702,13 @@ func (x *SearchResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
 	}
 	return nil
 }
-func (x *SearchResponse_Body) GetIdList() []*grpc.ObjectID {
+func (x *SearchResponse_Body) GetIdList() []grpc.ObjectID {
 	if x != nil {
 		return x.IdList
 	}
 	return nil
 }
-func (x *SearchResponse_Body) SetIdList(v []*grpc.ObjectID) {
+func (x *SearchResponse_Body) SetIdList(v []grpc.ObjectID) {
 	x.IdList = v
 }
 
@@ -4770,11 +4766,11 @@ func (x *SearchResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		switch key {
 		case "idList":
 			{
-				var f *grpc.ObjectID
-				var list []*grpc.ObjectID
+				var f grpc.ObjectID
+				var list []grpc.ObjectID
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc.ObjectID)
+					f = grpc.ObjectID{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -6077,7 +6073,7 @@ func (x *GetRangeResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
 
 type GetRangeHashRequest_Body struct {
 	Address *grpc.Address     `json:"address"`
-	Ranges  []*Range          `json:"ranges"`
+	Ranges  []Range           `json:"ranges"`
 	Salt    []byte            `json:"salt"`
 	Type    grpc.ChecksumType `json:"type"`
 }
@@ -6098,7 +6094,7 @@ func (x *GetRangeHashRequest_Body) StableSize() (size int) {
 	}
 	size += proto.NestedStructureSize(1, x.Address)
 	for i := range x.Ranges {
-		size += proto.NestedStructureSize(2, x.Ranges[i])
+		size += proto.NestedStructureSizeUnchecked(2, &x.Ranges[i])
 	}
 	size += proto.BytesSize(3, x.Salt)
 	size += proto.EnumSize(4, int32(x.Type))
@@ -6122,9 +6118,7 @@ func (x *GetRangeHashRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler)
 		x.Address.EmitProtobuf(mm.AppendMessage(1))
 	}
 	for i := range x.Ranges {
-		if x.Ranges[i] != nil {
-			x.Ranges[i].EmitProtobuf(mm.AppendMessage(2))
-		}
+		x.Ranges[i].EmitProtobuf(mm.AppendMessage(2))
 	}
 	if len(x.Salt) != 0 {
 		mm.AppendBytes(3, x.Salt)
@@ -6157,8 +6151,8 @@ func (x *GetRangeHashRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Ranges")
 			}
-			x.Ranges = append(x.Ranges, new(Range))
-			ff := x.Ranges[len(x.Ranges)-1]
+			x.Ranges = append(x.Ranges, Range{})
+			ff := &x.Ranges[len(x.Ranges)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -6187,13 +6181,13 @@ func (x *GetRangeHashRequest_Body) GetAddress() *grpc.Address {
 func (x *GetRangeHashRequest_Body) SetAddress(v *grpc.Address) {
 	x.Address = v
 }
-func (x *GetRangeHashRequest_Body) GetRanges() []*Range {
+func (x *GetRangeHashRequest_Body) GetRanges() []Range {
 	if x != nil {
 		return x.Ranges
 	}
 	return nil
 }
-func (x *GetRangeHashRequest_Body) SetRanges(v []*Range) {
+func (x *GetRangeHashRequest_Body) SetRanges(v []Range) {
 	x.Ranges = v
 }
 func (x *GetRangeHashRequest_Body) GetSalt() []byte {
@@ -6291,11 +6285,11 @@ func (x *GetRangeHashRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "ranges":
 			{
-				var f *Range
-				var list []*Range
+				var f Range
+				var list []Range
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Range)
+					f = Range{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -7855,7 +7849,7 @@ func (x *PatchRequest_Body_Patch) UnmarshalEasyJSON(in *jlexer.Lexer) {
 
 type PatchRequest_Body struct {
 	Address           *grpc.Address            `json:"address"`
-	NewAttributes     []*Header_Attribute      `json:"newAttributes"`
+	NewAttributes     []Header_Attribute       `json:"newAttributes"`
 	ReplaceAttributes bool                     `json:"replaceAttributes"`
 	Patch             *PatchRequest_Body_Patch `json:"patch"`
 }
@@ -7876,7 +7870,7 @@ func (x *PatchRequest_Body) StableSize() (size int) {
 	}
 	size += proto.NestedStructureSize(1, x.Address)
 	for i := range x.NewAttributes {
-		size += proto.NestedStructureSize(2, x.NewAttributes[i])
+		size += proto.NestedStructureSizeUnchecked(2, &x.NewAttributes[i])
 	}
 	size += proto.BoolSize(3, x.ReplaceAttributes)
 	size += proto.NestedStructureSize(4, x.Patch)
@@ -7900,9 +7894,7 @@ func (x *PatchRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		x.Address.EmitProtobuf(mm.AppendMessage(1))
 	}
 	for i := range x.NewAttributes {
-		if x.NewAttributes[i] != nil {
-			x.NewAttributes[i].EmitProtobuf(mm.AppendMessage(2))
-		}
+		x.NewAttributes[i].EmitProtobuf(mm.AppendMessage(2))
 	}
 	if x.ReplaceAttributes {
 		mm.AppendBool(3, x.ReplaceAttributes)
@@ -7935,8 +7927,8 @@ func (x *PatchRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "NewAttributes")
 			}
-			x.NewAttributes = append(x.NewAttributes, new(Header_Attribute))
-			ff := x.NewAttributes[len(x.NewAttributes)-1]
+			x.NewAttributes = append(x.NewAttributes, Header_Attribute{})
+			ff := &x.NewAttributes[len(x.NewAttributes)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -7968,13 +7960,13 @@ func (x *PatchRequest_Body) GetAddress() *grpc.Address {
 func (x *PatchRequest_Body) SetAddress(v *grpc.Address) {
 	x.Address = v
 }
-func (x *PatchRequest_Body) GetNewAttributes() []*Header_Attribute {
+func (x *PatchRequest_Body) GetNewAttributes() []Header_Attribute {
 	if x != nil {
 		return x.NewAttributes
 	}
 	return nil
 }
-func (x *PatchRequest_Body) SetNewAttributes(v []*Header_Attribute) {
+func (x *PatchRequest_Body) SetNewAttributes(v []Header_Attribute) {
 	x.NewAttributes = v
 }
 func (x *PatchRequest_Body) GetReplaceAttributes() bool {
@@ -8072,11 +8064,11 @@ func (x *PatchRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "newAttributes":
 			{
-				var f *Header_Attribute
-				var list []*Header_Attribute
+				var f Header_Attribute
+				var list []Header_Attribute
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Header_Attribute)
+					f = Header_Attribute{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/object/grpc/types_frostfs.pb.go b/object/grpc/types_frostfs.pb.go
index 04a3e29..4233417 100644
--- a/object/grpc/types_frostfs.pb.go
+++ b/object/grpc/types_frostfs.pb.go
@@ -600,12 +600,12 @@ func (x *Header_Attribute) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type Header_Split struct {
-	Parent          *grpc.ObjectID   `json:"parent"`
-	Previous        *grpc.ObjectID   `json:"previous"`
-	ParentSignature *grpc.Signature  `json:"parentSignature"`
-	ParentHeader    *Header          `json:"parentHeader"`
-	Children        []*grpc.ObjectID `json:"children"`
-	SplitId         []byte           `json:"splitID"`
+	Parent          *grpc.ObjectID  `json:"parent"`
+	Previous        *grpc.ObjectID  `json:"previous"`
+	ParentSignature *grpc.Signature `json:"parentSignature"`
+	ParentHeader    *Header         `json:"parentHeader"`
+	Children        []grpc.ObjectID `json:"children"`
+	SplitId         []byte          `json:"splitID"`
 }
 
 var (
@@ -627,7 +627,7 @@ func (x *Header_Split) StableSize() (size int) {
 	size += proto.NestedStructureSize(3, x.ParentSignature)
 	size += proto.NestedStructureSize(4, x.ParentHeader)
 	for i := range x.Children {
-		size += proto.NestedStructureSize(5, x.Children[i])
+		size += proto.NestedStructureSizeUnchecked(5, &x.Children[i])
 	}
 	size += proto.BytesSize(6, x.SplitId)
 	return size
@@ -659,9 +659,7 @@ func (x *Header_Split) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		x.ParentHeader.EmitProtobuf(mm.AppendMessage(4))
 	}
 	for i := range x.Children {
-		if x.Children[i] != nil {
-			x.Children[i].EmitProtobuf(mm.AppendMessage(5))
-		}
+		x.Children[i].EmitProtobuf(mm.AppendMessage(5))
 	}
 	if len(x.SplitId) != 0 {
 		mm.AppendBytes(6, x.SplitId)
@@ -718,8 +716,8 @@ func (x *Header_Split) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Children")
 			}
-			x.Children = append(x.Children, new(grpc.ObjectID))
-			ff := x.Children[len(x.Children)-1]
+			x.Children = append(x.Children, grpc.ObjectID{})
+			ff := &x.Children[len(x.Children)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -769,13 +767,13 @@ func (x *Header_Split) GetParentHeader() *Header {
 func (x *Header_Split) SetParentHeader(v *Header) {
 	x.ParentHeader = v
 }
-func (x *Header_Split) GetChildren() []*grpc.ObjectID {
+func (x *Header_Split) GetChildren() []grpc.ObjectID {
 	if x != nil {
 		return x.Children
 	}
 	return nil
 }
-func (x *Header_Split) SetChildren(v []*grpc.ObjectID) {
+func (x *Header_Split) SetChildren(v []grpc.ObjectID) {
 	x.Children = v
 }
 func (x *Header_Split) GetSplitId() []byte {
@@ -895,11 +893,11 @@ func (x *Header_Split) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "children":
 			{
-				var f *grpc.ObjectID
-				var list []*grpc.ObjectID
+				var f grpc.ObjectID
+				var list []grpc.ObjectID
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc.ObjectID)
+					f = grpc.ObjectID{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -923,14 +921,14 @@ func (x *Header_Split) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type Header_EC struct {
-	Parent              *grpc.ObjectID      `json:"parent"`
-	Index               uint32              `json:"index"`
-	Total               uint32              `json:"total"`
-	HeaderLength        uint32              `json:"headerLength"`
-	Header              []byte              `json:"header"`
-	ParentSplitId       []byte              `json:"parentSplitID"`
-	ParentSplitParentId *grpc.ObjectID      `json:"parentSplitParentID"`
-	ParentAttributes    []*Header_Attribute `json:"parentAttributes"`
+	Parent              *grpc.ObjectID     `json:"parent"`
+	Index               uint32             `json:"index"`
+	Total               uint32             `json:"total"`
+	HeaderLength        uint32             `json:"headerLength"`
+	Header              []byte             `json:"header"`
+	ParentSplitId       []byte             `json:"parentSplitID"`
+	ParentSplitParentId *grpc.ObjectID     `json:"parentSplitParentID"`
+	ParentAttributes    []Header_Attribute `json:"parentAttributes"`
 }
 
 var (
@@ -955,7 +953,7 @@ func (x *Header_EC) StableSize() (size int) {
 	size += proto.BytesSize(6, x.ParentSplitId)
 	size += proto.NestedStructureSize(7, x.ParentSplitParentId)
 	for i := range x.ParentAttributes {
-		size += proto.NestedStructureSize(8, x.ParentAttributes[i])
+		size += proto.NestedStructureSizeUnchecked(8, &x.ParentAttributes[i])
 	}
 	return size
 }
@@ -995,9 +993,7 @@ func (x *Header_EC) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		x.ParentSplitParentId.EmitProtobuf(mm.AppendMessage(7))
 	}
 	for i := range x.ParentAttributes {
-		if x.ParentAttributes[i] != nil {
-			x.ParentAttributes[i].EmitProtobuf(mm.AppendMessage(8))
-		}
+		x.ParentAttributes[i].EmitProtobuf(mm.AppendMessage(8))
 	}
 }
 
@@ -1063,8 +1059,8 @@ func (x *Header_EC) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "ParentAttributes")
 			}
-			x.ParentAttributes = append(x.ParentAttributes, new(Header_Attribute))
-			ff := x.ParentAttributes[len(x.ParentAttributes)-1]
+			x.ParentAttributes = append(x.ParentAttributes, Header_Attribute{})
+			ff := &x.ParentAttributes[len(x.ParentAttributes)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1135,13 +1131,13 @@ func (x *Header_EC) GetParentSplitParentId() *grpc.ObjectID {
 func (x *Header_EC) SetParentSplitParentId(v *grpc.ObjectID) {
 	x.ParentSplitParentId = v
 }
-func (x *Header_EC) GetParentAttributes() []*Header_Attribute {
+func (x *Header_EC) GetParentAttributes() []Header_Attribute {
 	if x != nil {
 		return x.ParentAttributes
 	}
 	return nil
 }
-func (x *Header_EC) SetParentAttributes(v []*Header_Attribute) {
+func (x *Header_EC) SetParentAttributes(v []Header_Attribute) {
 	x.ParentAttributes = v
 }
 
@@ -1278,11 +1274,11 @@ func (x *Header_EC) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "parentAttributes":
 			{
-				var f *Header_Attribute
-				var list []*Header_Attribute
+				var f Header_Attribute
+				var list []Header_Attribute
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Header_Attribute)
+					f = Header_Attribute{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1309,7 +1305,7 @@ type Header struct {
 	ObjectType      ObjectType          `json:"objectType"`
 	HomomorphicHash *grpc.Checksum      `json:"homomorphicHash"`
 	SessionToken    *grpc1.SessionToken `json:"sessionToken"`
-	Attributes      []*Header_Attribute `json:"attributes"`
+	Attributes      []Header_Attribute  `json:"attributes"`
 	Split           *Header_Split       `json:"split"`
 	Ec              *Header_EC          `json:"ec"`
 }
@@ -1338,7 +1334,7 @@ func (x *Header) StableSize() (size int) {
 	size += proto.NestedStructureSize(8, x.HomomorphicHash)
 	size += proto.NestedStructureSize(9, x.SessionToken)
 	for i := range x.Attributes {
-		size += proto.NestedStructureSize(10, x.Attributes[i])
+		size += proto.NestedStructureSizeUnchecked(10, &x.Attributes[i])
 	}
 	size += proto.NestedStructureSize(11, x.Split)
 	size += proto.NestedStructureSize(12, x.Ec)
@@ -1386,9 +1382,7 @@ func (x *Header) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		x.SessionToken.EmitProtobuf(mm.AppendMessage(9))
 	}
 	for i := range x.Attributes {
-		if x.Attributes[i] != nil {
-			x.Attributes[i].EmitProtobuf(mm.AppendMessage(10))
-		}
+		x.Attributes[i].EmitProtobuf(mm.AppendMessage(10))
 	}
 	if x.Split != nil {
 		x.Split.EmitProtobuf(mm.AppendMessage(11))
@@ -1484,8 +1478,8 @@ func (x *Header) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Attributes")
 			}
-			x.Attributes = append(x.Attributes, new(Header_Attribute))
-			ff := x.Attributes[len(x.Attributes)-1]
+			x.Attributes = append(x.Attributes, Header_Attribute{})
+			ff := &x.Attributes[len(x.Attributes)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1592,13 +1586,13 @@ func (x *Header) GetSessionToken() *grpc1.SessionToken {
 func (x *Header) SetSessionToken(v *grpc1.SessionToken) {
 	x.SessionToken = v
 }
-func (x *Header) GetAttributes() []*Header_Attribute {
+func (x *Header) GetAttributes() []Header_Attribute {
 	if x != nil {
 		return x.Attributes
 	}
 	return nil
 }
-func (x *Header) SetAttributes(v []*Header_Attribute) {
+func (x *Header) SetAttributes(v []Header_Attribute) {
 	x.Attributes = v
 }
 func (x *Header) GetSplit() *Header_Split {
@@ -1805,11 +1799,11 @@ func (x *Header) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "attributes":
 			{
-				var f *Header_Attribute
-				var list []*Header_Attribute
+				var f Header_Attribute
+				var list []Header_Attribute
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Header_Attribute)
+					f = Header_Attribute{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -2469,7 +2463,7 @@ func (x *ECInfo_Chunk) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type ECInfo struct {
-	Chunks []*ECInfo_Chunk `json:"chunks"`
+	Chunks []ECInfo_Chunk `json:"chunks"`
 }
 
 var (
@@ -2487,7 +2481,7 @@ func (x *ECInfo) StableSize() (size int) {
 		return 0
 	}
 	for i := range x.Chunks {
-		size += proto.NestedStructureSize(1, x.Chunks[i])
+		size += proto.NestedStructureSizeUnchecked(1, &x.Chunks[i])
 	}
 	return size
 }
@@ -2506,9 +2500,7 @@ func (x *ECInfo) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		return
 	}
 	for i := range x.Chunks {
-		if x.Chunks[i] != nil {
-			x.Chunks[i].EmitProtobuf(mm.AppendMessage(1))
-		}
+		x.Chunks[i].EmitProtobuf(mm.AppendMessage(1))
 	}
 }
 
@@ -2526,8 +2518,8 @@ func (x *ECInfo) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Chunks")
 			}
-			x.Chunks = append(x.Chunks, new(ECInfo_Chunk))
-			ff := x.Chunks[len(x.Chunks)-1]
+			x.Chunks = append(x.Chunks, ECInfo_Chunk{})
+			ff := &x.Chunks[len(x.Chunks)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -2535,13 +2527,13 @@ func (x *ECInfo) UnmarshalProtobuf(src []byte) (err error) {
 	}
 	return nil
 }
-func (x *ECInfo) GetChunks() []*ECInfo_Chunk {
+func (x *ECInfo) GetChunks() []ECInfo_Chunk {
 	if x != nil {
 		return x.Chunks
 	}
 	return nil
 }
-func (x *ECInfo) SetChunks(v []*ECInfo_Chunk) {
+func (x *ECInfo) SetChunks(v []ECInfo_Chunk) {
 	x.Chunks = v
 }
 
@@ -2599,11 +2591,11 @@ func (x *ECInfo) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		switch key {
 		case "chunks":
 			{
-				var f *ECInfo_Chunk
-				var list []*ECInfo_Chunk
+				var f ECInfo_Chunk
+				var list []ECInfo_Chunk
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(ECInfo_Chunk)
+					f = ECInfo_Chunk{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/object/lock.go b/object/lock.go
index 62ba4a9..585fd09 100644
--- a/object/lock.go
+++ b/object/lock.go
@@ -89,13 +89,13 @@ func (x *Lock) ToGRPCMessage() grpc.Message {
 	if x != nil {
 		m = new(lock.Lock)
 
-		var members []*refsGRPC.ObjectID
+		var members []refsGRPC.ObjectID
 
 		if x.members != nil {
-			members = make([]*refsGRPC.ObjectID, len(x.members))
+			members = make([]refsGRPC.ObjectID, len(x.members))
 
 			for i := range x.members {
-				members[i] = x.members[i].ToGRPCMessage().(*refsGRPC.ObjectID)
+				members[i] = *x.members[i].ToGRPCMessage().(*refsGRPC.ObjectID)
 			}
 		}
 
@@ -119,7 +119,7 @@ func (x *Lock) FromGRPCMessage(m grpc.Message) error {
 		var err error
 
 		for i := range x.members {
-			err = x.members[i].FromGRPCMessage(members[i])
+			err = x.members[i].FromGRPCMessage(&members[i])
 			if err != nil {
 				return err
 			}
diff --git a/refs/convert.go b/refs/convert.go
index 6f06783..da31cdb 100644
--- a/refs/convert.go
+++ b/refs/convert.go
@@ -52,28 +52,26 @@ func (c *ContainerID) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func ContainerIDsToGRPCMessage(ids []ContainerID) (res []*refs.ContainerID) {
+func ContainerIDsToGRPCMessage(ids []ContainerID) (res []refs.ContainerID) {
 	if ids != nil {
-		res = make([]*refs.ContainerID, 0, len(ids))
+		res = make([]refs.ContainerID, 0, len(ids))
 
 		for i := range ids {
-			res = append(res, ids[i].ToGRPCMessage().(*refs.ContainerID))
+			res = append(res, *ids[i].ToGRPCMessage().(*refs.ContainerID))
 		}
 	}
 
 	return
 }
 
-func ContainerIDsFromGRPCMessage(idsV2 []*refs.ContainerID) (res []ContainerID, err error) {
+func ContainerIDsFromGRPCMessage(idsV2 []refs.ContainerID) (res []ContainerID, err error) {
 	if idsV2 != nil {
 		res = make([]ContainerID, len(idsV2))
 
 		for i := range idsV2 {
-			if idsV2[i] != nil {
-				err = res[i].FromGRPCMessage(idsV2[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&idsV2[i])
+			if err != nil {
+				return
 			}
 		}
 	}
@@ -104,28 +102,26 @@ func (o *ObjectID) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func ObjectIDListToGRPCMessage(ids []ObjectID) (res []*refs.ObjectID) {
+func ObjectIDListToGRPCMessage(ids []ObjectID) (res []refs.ObjectID) {
 	if ids != nil {
-		res = make([]*refs.ObjectID, 0, len(ids))
+		res = make([]refs.ObjectID, 0, len(ids))
 
 		for i := range ids {
-			res = append(res, ids[i].ToGRPCMessage().(*refs.ObjectID))
+			res = append(res, *ids[i].ToGRPCMessage().(*refs.ObjectID))
 		}
 	}
 
 	return
 }
 
-func ObjectIDListFromGRPCMessage(idsV2 []*refs.ObjectID) (res []ObjectID, err error) {
+func ObjectIDListFromGRPCMessage(idsV2 []refs.ObjectID) (res []ObjectID, err error) {
 	if idsV2 != nil {
 		res = make([]ObjectID, len(idsV2))
 
 		for i := range idsV2 {
-			if idsV2[i] != nil {
-				err = res[i].FromGRPCMessage(idsV2[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&idsV2[i])
+			if err != nil {
+				return
 			}
 		}
 	}
diff --git a/session/convert.go b/session/convert.go
index b7f334e..d0e83fa 100644
--- a/session/convert.go
+++ b/session/convert.go
@@ -207,28 +207,26 @@ func (x *XHeader) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func XHeadersToGRPC(xs []XHeader) (res []*session.XHeader) {
+func XHeadersToGRPC(xs []XHeader) (res []session.XHeader) {
 	if xs != nil {
-		res = make([]*session.XHeader, 0, len(xs))
+		res = make([]session.XHeader, 0, len(xs))
 
 		for i := range xs {
-			res = append(res, xs[i].ToGRPCMessage().(*session.XHeader))
+			res = append(res, *xs[i].ToGRPCMessage().(*session.XHeader))
 		}
 	}
 
 	return
 }
 
-func XHeadersFromGRPC(xs []*session.XHeader) (res []XHeader, err error) {
+func XHeadersFromGRPC(xs []session.XHeader) (res []XHeader, err error) {
 	if xs != nil {
 		res = make([]XHeader, len(xs))
 
 		for i := range xs {
-			if xs[i] != nil {
-				err = res[i].FromGRPCMessage(xs[i])
-				if err != nil {
-					return
-				}
+			err = res[i].FromGRPCMessage(&xs[i])
+			if err != nil {
+				return
 			}
 		}
 	}
diff --git a/session/grpc/types_frostfs.pb.go b/session/grpc/types_frostfs.pb.go
index 4f8bf81..41ff5d9 100644
--- a/session/grpc/types_frostfs.pb.go
+++ b/session/grpc/types_frostfs.pb.go
@@ -72,7 +72,7 @@ func (x *ObjectSessionContext_Verb) FromString(s string) bool {
 
 type ObjectSessionContext_Target struct {
 	Container *grpc.ContainerID `json:"container"`
-	Objects   []*grpc.ObjectID  `json:"objects"`
+	Objects   []grpc.ObjectID   `json:"objects"`
 }
 
 var (
@@ -91,7 +91,7 @@ func (x *ObjectSessionContext_Target) StableSize() (size int) {
 	}
 	size += proto.NestedStructureSize(1, x.Container)
 	for i := range x.Objects {
-		size += proto.NestedStructureSize(2, x.Objects[i])
+		size += proto.NestedStructureSizeUnchecked(2, &x.Objects[i])
 	}
 	return size
 }
@@ -113,9 +113,7 @@ func (x *ObjectSessionContext_Target) EmitProtobuf(mm *easyproto.MessageMarshale
 		x.Container.EmitProtobuf(mm.AppendMessage(1))
 	}
 	for i := range x.Objects {
-		if x.Objects[i] != nil {
-			x.Objects[i].EmitProtobuf(mm.AppendMessage(2))
-		}
+		x.Objects[i].EmitProtobuf(mm.AppendMessage(2))
 	}
 }
 
@@ -142,8 +140,8 @@ func (x *ObjectSessionContext_Target) UnmarshalProtobuf(src []byte) (err error)
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Objects")
 			}
-			x.Objects = append(x.Objects, new(grpc.ObjectID))
-			ff := x.Objects[len(x.Objects)-1]
+			x.Objects = append(x.Objects, grpc.ObjectID{})
+			ff := &x.Objects[len(x.Objects)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -160,13 +158,13 @@ func (x *ObjectSessionContext_Target) GetContainer() *grpc.ContainerID {
 func (x *ObjectSessionContext_Target) SetContainer(v *grpc.ContainerID) {
 	x.Container = v
 }
-func (x *ObjectSessionContext_Target) GetObjects() []*grpc.ObjectID {
+func (x *ObjectSessionContext_Target) GetObjects() []grpc.ObjectID {
 	if x != nil {
 		return x.Objects
 	}
 	return nil
 }
-func (x *ObjectSessionContext_Target) SetObjects(v []*grpc.ObjectID) {
+func (x *ObjectSessionContext_Target) SetObjects(v []grpc.ObjectID) {
 	x.Objects = v
 }
 
@@ -236,11 +234,11 @@ func (x *ObjectSessionContext_Target) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "objects":
 			{
-				var f *grpc.ObjectID
-				var list []*grpc.ObjectID
+				var f grpc.ObjectID
+				var list []grpc.ObjectID
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc.ObjectID)
+					f = grpc.ObjectID{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1551,7 +1549,7 @@ type RequestMetaHeader struct {
 	Version      *grpc.Version      `json:"version"`
 	Epoch        uint64             `json:"epoch"`
 	Ttl          uint32             `json:"ttl"`
-	XHeaders     []*XHeader         `json:"xHeaders"`
+	XHeaders     []XHeader          `json:"xHeaders"`
 	SessionToken *SessionToken      `json:"sessionToken"`
 	BearerToken  *grpc1.BearerToken `json:"bearerToken"`
 	Origin       *RequestMetaHeader `json:"origin"`
@@ -1576,7 +1574,7 @@ func (x *RequestMetaHeader) StableSize() (size int) {
 	size += proto.UInt64Size(2, x.Epoch)
 	size += proto.UInt32Size(3, x.Ttl)
 	for i := range x.XHeaders {
-		size += proto.NestedStructureSize(4, x.XHeaders[i])
+		size += proto.NestedStructureSizeUnchecked(4, &x.XHeaders[i])
 	}
 	size += proto.NestedStructureSize(5, x.SessionToken)
 	size += proto.NestedStructureSize(6, x.BearerToken)
@@ -1608,9 +1606,7 @@ func (x *RequestMetaHeader) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendUint32(3, x.Ttl)
 	}
 	for i := range x.XHeaders {
-		if x.XHeaders[i] != nil {
-			x.XHeaders[i].EmitProtobuf(mm.AppendMessage(4))
-		}
+		x.XHeaders[i].EmitProtobuf(mm.AppendMessage(4))
 	}
 	if x.SessionToken != nil {
 		x.SessionToken.EmitProtobuf(mm.AppendMessage(5))
@@ -1661,8 +1657,8 @@ func (x *RequestMetaHeader) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "XHeaders")
 			}
-			x.XHeaders = append(x.XHeaders, new(XHeader))
-			ff := x.XHeaders[len(x.XHeaders)-1]
+			x.XHeaders = append(x.XHeaders, XHeader{})
+			ff := &x.XHeaders[len(x.XHeaders)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1730,13 +1726,13 @@ func (x *RequestMetaHeader) GetTtl() uint32 {
 func (x *RequestMetaHeader) SetTtl(v uint32) {
 	x.Ttl = v
 }
-func (x *RequestMetaHeader) GetXHeaders() []*XHeader {
+func (x *RequestMetaHeader) GetXHeaders() []XHeader {
 	if x != nil {
 		return x.XHeaders
 	}
 	return nil
 }
-func (x *RequestMetaHeader) SetXHeaders(v []*XHeader) {
+func (x *RequestMetaHeader) SetXHeaders(v []XHeader) {
 	x.XHeaders = v
 }
 func (x *RequestMetaHeader) GetSessionToken() *SessionToken {
@@ -1884,11 +1880,11 @@ func (x *RequestMetaHeader) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "xHeaders":
 			{
-				var f *XHeader
-				var list []*XHeader
+				var f XHeader
+				var list []XHeader
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(XHeader)
+					f = XHeader{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
@@ -1936,7 +1932,7 @@ type ResponseMetaHeader struct {
 	Version  *grpc.Version       `json:"version"`
 	Epoch    uint64              `json:"epoch"`
 	Ttl      uint32              `json:"ttl"`
-	XHeaders []*XHeader          `json:"xHeaders"`
+	XHeaders []XHeader           `json:"xHeaders"`
 	Origin   *ResponseMetaHeader `json:"origin"`
 	Status   *grpc2.Status       `json:"status"`
 }
@@ -1959,7 +1955,7 @@ func (x *ResponseMetaHeader) StableSize() (size int) {
 	size += proto.UInt64Size(2, x.Epoch)
 	size += proto.UInt32Size(3, x.Ttl)
 	for i := range x.XHeaders {
-		size += proto.NestedStructureSize(4, x.XHeaders[i])
+		size += proto.NestedStructureSizeUnchecked(4, &x.XHeaders[i])
 	}
 	size += proto.NestedStructureSize(5, x.Origin)
 	size += proto.NestedStructureSize(6, x.Status)
@@ -1989,9 +1985,7 @@ func (x *ResponseMetaHeader) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendUint32(3, x.Ttl)
 	}
 	for i := range x.XHeaders {
-		if x.XHeaders[i] != nil {
-			x.XHeaders[i].EmitProtobuf(mm.AppendMessage(4))
-		}
+		x.XHeaders[i].EmitProtobuf(mm.AppendMessage(4))
 	}
 	if x.Origin != nil {
 		x.Origin.EmitProtobuf(mm.AppendMessage(5))
@@ -2036,8 +2030,8 @@ func (x *ResponseMetaHeader) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "XHeaders")
 			}
-			x.XHeaders = append(x.XHeaders, new(XHeader))
-			ff := x.XHeaders[len(x.XHeaders)-1]
+			x.XHeaders = append(x.XHeaders, XHeader{})
+			ff := &x.XHeaders[len(x.XHeaders)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -2090,13 +2084,13 @@ func (x *ResponseMetaHeader) GetTtl() uint32 {
 func (x *ResponseMetaHeader) SetTtl(v uint32) {
 	x.Ttl = v
 }
-func (x *ResponseMetaHeader) GetXHeaders() []*XHeader {
+func (x *ResponseMetaHeader) GetXHeaders() []XHeader {
 	if x != nil {
 		return x.XHeaders
 	}
 	return nil
 }
-func (x *ResponseMetaHeader) SetXHeaders(v []*XHeader) {
+func (x *ResponseMetaHeader) SetXHeaders(v []XHeader) {
 	x.XHeaders = v
 }
 func (x *ResponseMetaHeader) GetOrigin() *ResponseMetaHeader {
@@ -2216,11 +2210,11 @@ func (x *ResponseMetaHeader) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "xHeaders":
 			{
-				var f *XHeader
-				var list []*XHeader
+				var f XHeader
+				var list []XHeader
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(XHeader)
+					f = XHeader{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/status/convert.go b/status/convert.go
index 0743952..3c5b5bf 100644
--- a/status/convert.go
+++ b/status/convert.go
@@ -48,13 +48,13 @@ func (x *Status) ToGRPCMessage() grpc.Message {
 		m.SetCode(CodeToGRPC(x.code))
 		m.SetMessage(x.msg)
 
-		var ds []*status.Status_Detail
+		var ds []status.Status_Detail
 
 		if ln := len(x.details); ln > 0 {
-			ds = make([]*status.Status_Detail, 0, ln)
+			ds = make([]status.Status_Detail, 0, ln)
 
 			for i := 0; i < ln; i++ {
-				ds = append(ds, x.details[i].ToGRPCMessage().(*status.Status_Detail))
+				ds = append(ds, *x.details[i].ToGRPCMessage().(*status.Status_Detail))
 			}
 		}
 
@@ -81,10 +81,8 @@ func (x *Status) FromGRPCMessage(m grpc.Message) error {
 		ds = make([]Detail, ln)
 
 		for i := 0; i < ln; i++ {
-			if dsV2[i] != nil {
-				if err := ds[i].FromGRPCMessage(dsV2[i]); err != nil {
-					return err
-				}
+			if err := ds[i].FromGRPCMessage(&dsV2[i]); err != nil {
+				return err
 			}
 		}
 	}
diff --git a/status/grpc/types_frostfs.pb.go b/status/grpc/types_frostfs.pb.go
index 5012491..29dfebe 100644
--- a/status/grpc/types_frostfs.pb.go
+++ b/status/grpc/types_frostfs.pb.go
@@ -429,9 +429,9 @@ func (x *Status_Detail) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type Status struct {
-	Code    uint32           `json:"code"`
-	Message string           `json:"message"`
-	Details []*Status_Detail `json:"details"`
+	Code    uint32          `json:"code"`
+	Message string          `json:"message"`
+	Details []Status_Detail `json:"details"`
 }
 
 var (
@@ -451,7 +451,7 @@ func (x *Status) StableSize() (size int) {
 	size += proto.UInt32Size(1, x.Code)
 	size += proto.StringSize(2, x.Message)
 	for i := range x.Details {
-		size += proto.NestedStructureSize(3, x.Details[i])
+		size += proto.NestedStructureSizeUnchecked(3, &x.Details[i])
 	}
 	return size
 }
@@ -476,9 +476,7 @@ func (x *Status) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendString(2, x.Message)
 	}
 	for i := range x.Details {
-		if x.Details[i] != nil {
-			x.Details[i].EmitProtobuf(mm.AppendMessage(3))
-		}
+		x.Details[i].EmitProtobuf(mm.AppendMessage(3))
 	}
 }
 
@@ -508,8 +506,8 @@ func (x *Status) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Details")
 			}
-			x.Details = append(x.Details, new(Status_Detail))
-			ff := x.Details[len(x.Details)-1]
+			x.Details = append(x.Details, Status_Detail{})
+			ff := &x.Details[len(x.Details)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -535,13 +533,13 @@ func (x *Status) GetMessage() string {
 func (x *Status) SetMessage(v string) {
 	x.Message = v
 }
-func (x *Status) GetDetails() []*Status_Detail {
+func (x *Status) GetDetails() []Status_Detail {
 	if x != nil {
 		return x.Details
 	}
 	return nil
 }
-func (x *Status) SetDetails(v []*Status_Detail) {
+func (x *Status) SetDetails(v []Status_Detail) {
 	x.Details = v
 }
 
@@ -621,11 +619,11 @@ func (x *Status) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "details":
 			{
-				var f *Status_Detail
-				var list []*Status_Detail
+				var f Status_Detail
+				var list []Status_Detail
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(Status_Detail)
+					f = Status_Detail{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/tombstone/grpc/types_frostfs.pb.go b/tombstone/grpc/types_frostfs.pb.go
index 8c2e83c..f7bc48c 100644
--- a/tombstone/grpc/types_frostfs.pb.go
+++ b/tombstone/grpc/types_frostfs.pb.go
@@ -15,9 +15,9 @@ import (
 )
 
 type Tombstone struct {
-	ExpirationEpoch uint64           `json:"expirationEpoch"`
-	SplitId         []byte           `json:"splitID"`
-	Members         []*grpc.ObjectID `json:"members"`
+	ExpirationEpoch uint64          `json:"expirationEpoch"`
+	SplitId         []byte          `json:"splitID"`
+	Members         []grpc.ObjectID `json:"members"`
 }
 
 var (
@@ -37,7 +37,7 @@ func (x *Tombstone) StableSize() (size int) {
 	size += proto.UInt64Size(1, x.ExpirationEpoch)
 	size += proto.BytesSize(2, x.SplitId)
 	for i := range x.Members {
-		size += proto.NestedStructureSize(3, x.Members[i])
+		size += proto.NestedStructureSizeUnchecked(3, &x.Members[i])
 	}
 	return size
 }
@@ -62,9 +62,7 @@ func (x *Tombstone) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendBytes(2, x.SplitId)
 	}
 	for i := range x.Members {
-		if x.Members[i] != nil {
-			x.Members[i].EmitProtobuf(mm.AppendMessage(3))
-		}
+		x.Members[i].EmitProtobuf(mm.AppendMessage(3))
 	}
 }
 
@@ -94,8 +92,8 @@ func (x *Tombstone) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "Members")
 			}
-			x.Members = append(x.Members, new(grpc.ObjectID))
-			ff := x.Members[len(x.Members)-1]
+			x.Members = append(x.Members, grpc.ObjectID{})
+			ff := &x.Members[len(x.Members)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -121,13 +119,13 @@ func (x *Tombstone) GetSplitId() []byte {
 func (x *Tombstone) SetSplitId(v []byte) {
 	x.SplitId = v
 }
-func (x *Tombstone) GetMembers() []*grpc.ObjectID {
+func (x *Tombstone) GetMembers() []grpc.ObjectID {
 	if x != nil {
 		return x.Members
 	}
 	return nil
 }
-func (x *Tombstone) SetMembers(v []*grpc.ObjectID) {
+func (x *Tombstone) SetMembers(v []grpc.ObjectID) {
 	x.Members = v
 }
 
@@ -207,11 +205,11 @@ func (x *Tombstone) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "members":
 			{
-				var f *grpc.ObjectID
-				var list []*grpc.ObjectID
+				var f grpc.ObjectID
+				var list []grpc.ObjectID
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(grpc.ObjectID)
+					f = grpc.ObjectID{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/util/proto/marshal_test.go b/util/proto/marshal_test.go
index a848bb5..1cd7005 100644
--- a/util/proto/marshal_test.go
+++ b/util/proto/marshal_test.go
@@ -133,10 +133,10 @@ func randIntSlice[T protoInt](n int, includeZero bool) []T {
 	return r
 }
 
-func uint32SliceToAux(s []uint32) []*generated.RepPrimitives_Aux {
-	r := make([]*generated.RepPrimitives_Aux, len(s))
+func uint32SliceToAux(s []uint32) []generated.RepPrimitives_Aux {
+	r := make([]generated.RepPrimitives_Aux, len(s))
 	for i := range s {
-		r[i] = &generated.RepPrimitives_Aux{s[i]}
+		r[i] = generated.RepPrimitives_Aux{InnerField: s[i]}
 	}
 	return r
 }
diff --git a/util/proto/test/custom/test_frostfs.pb.go b/util/proto/test/custom/test_frostfs.pb.go
index f3b958f..97efa51 100644
--- a/util/proto/test/custom/test_frostfs.pb.go
+++ b/util/proto/test/custom/test_frostfs.pb.go
@@ -932,14 +932,14 @@ func (x *RepPrimitives_Aux) UnmarshalEasyJSON(in *jlexer.Lexer) {
 }
 
 type RepPrimitives struct {
-	FieldA   [][]byte             `json:"fieldA"`
-	FieldB   []string             `json:"fieldB"`
-	FieldC   []int32              `json:"fieldC"`
-	FieldD   []uint32             `json:"fieldD"`
-	FieldE   []int64              `json:"fieldE"`
-	FieldF   []uint64             `json:"fieldF"`
-	FieldFu  []uint64             `json:"fieldFu"`
-	FieldAux []*RepPrimitives_Aux `json:"fieldAux"`
+	FieldA   [][]byte            `json:"fieldA"`
+	FieldB   []string            `json:"fieldB"`
+	FieldC   []int32             `json:"fieldC"`
+	FieldD   []uint32            `json:"fieldD"`
+	FieldE   []int64             `json:"fieldE"`
+	FieldF   []uint64            `json:"fieldF"`
+	FieldFu  []uint64            `json:"fieldFu"`
+	FieldAux []RepPrimitives_Aux `json:"fieldAux"`
 }
 
 var (
@@ -971,7 +971,7 @@ func (x *RepPrimitives) StableSize() (size int) {
 		size += protowire.SizeGroup(protowire.Number(7), protowire.SizeVarint(x.FieldFu[i]))
 	}
 	for i := range x.FieldAux {
-		size += proto.NestedStructureSize(8, x.FieldAux[i])
+		size += proto.NestedStructureSizeUnchecked(8, &x.FieldAux[i])
 	}
 	return size
 }
@@ -1011,9 +1011,7 @@ func (x *RepPrimitives) EmitProtobuf(mm *easyproto.MessageMarshaler) {
 		mm.AppendUint64(7, x.FieldFu[j])
 	}
 	for i := range x.FieldAux {
-		if x.FieldAux[i] != nil {
-			x.FieldAux[i].EmitProtobuf(mm.AppendMessage(8))
-		}
+		x.FieldAux[i].EmitProtobuf(mm.AppendMessage(8))
 	}
 }
 
@@ -1073,8 +1071,8 @@ func (x *RepPrimitives) UnmarshalProtobuf(src []byte) (err error) {
 			if !ok {
 				return fmt.Errorf("cannot unmarshal field %s", "FieldAux")
 			}
-			x.FieldAux = append(x.FieldAux, new(RepPrimitives_Aux))
-			ff := x.FieldAux[len(x.FieldAux)-1]
+			x.FieldAux = append(x.FieldAux, RepPrimitives_Aux{})
+			ff := &x.FieldAux[len(x.FieldAux)-1]
 			if err := ff.UnmarshalProtobuf(data); err != nil {
 				return fmt.Errorf("unmarshal: %w", err)
 			}
@@ -1145,13 +1143,13 @@ func (x *RepPrimitives) GetFieldFu() []uint64 {
 func (x *RepPrimitives) SetFieldFu(v []uint64) {
 	x.FieldFu = v
 }
-func (x *RepPrimitives) GetFieldAux() []*RepPrimitives_Aux {
+func (x *RepPrimitives) GetFieldAux() []RepPrimitives_Aux {
 	if x != nil {
 		return x.FieldAux
 	}
 	return nil
 }
-func (x *RepPrimitives) SetFieldAux(v []*RepPrimitives_Aux) {
+func (x *RepPrimitives) SetFieldAux(v []RepPrimitives_Aux) {
 	x.FieldAux = v
 }
 
@@ -1384,11 +1382,11 @@ func (x *RepPrimitives) UnmarshalEasyJSON(in *jlexer.Lexer) {
 			}
 		case "fieldAux":
 			{
-				var f *RepPrimitives_Aux
-				var list []*RepPrimitives_Aux
+				var f RepPrimitives_Aux
+				var list []RepPrimitives_Aux
 				in.Delim('[')
 				for !in.IsDelim(']') {
-					f = new(RepPrimitives_Aux)
+					f = RepPrimitives_Aux{}
 					f.UnmarshalEasyJSON(in)
 					list = append(list, f)
 					in.WantComma()
diff --git a/util/protogen/internalgengo/json.go b/util/protogen/internalgengo/json.go
index 4ae24e7..f7cd284 100644
--- a/util/protogen/internalgengo/json.go
+++ b/util/protogen/internalgengo/json.go
@@ -117,7 +117,7 @@ func emitJSONFieldRead(g *protogen.GeneratedFile, f *protogen.Field, name string
 		template = "%s = in.Bytes()"
 	case protoreflect.MessageKind:
 		if f.Desc.IsList() {
-			g.P("f = new(", fieldType(g, f)[3:], ")")
+			g.P("f = ", fieldType(g, f)[2:], "{}")
 		} else {
 			g.P("f = new(", fieldType(g, f)[1:], ")")
 		}
diff --git a/util/protogen/internalgengo/proto.go b/util/protogen/internalgengo/proto.go
index 8894cde..1467541 100644
--- a/util/protogen/internalgengo/proto.go
+++ b/util/protogen/internalgengo/proto.go
@@ -39,8 +39,8 @@ func emitFieldUnmarshal(g *protogen.GeneratedFile, f *protogen.Field) {
 		g.P("data, ok := fc.MessageData()")
 		g.P(`if !ok { return fmt.Errorf("cannot unmarshal field %s", "`, f.GoName, `") }`)
 		if f.Desc.IsList() {
-			g.P(name, " = append(", name, ", new(", fieldType(g, f)[3:], "))")
-			g.P("ff := ", name, "[len(", name, ")-1]")
+			g.P(name, " = append(", name, ", ", fieldType(g, f)[2:], "{})")
+			g.P("ff := &", name, "[len(", name, ")-1]")
 			name = "ff"
 		} else if f.Oneof != nil {
 			const tmp = "oneofField"
@@ -172,11 +172,12 @@ func emitMarshalRaw(g *protogen.GeneratedFile, f *protogen.Field, name string) {
 			defer g.P("}")
 
 			name += "[i]"
+		} else {
+			g.P("if ", notNil(name), " {")
+			defer g.P("}")
 		}
 
-		g.P("if ", notNil(name), " {")
 		g.P(name, ".EmitProtobuf(mm.AppendMessage(", f.Desc.Number(), "))")
-		g.P("}")
 		return
 	}
 
diff --git a/util/protogen/internalgengo/proto_field_type.go b/util/protogen/internalgengo/proto_field_type.go
index 09f6884..0096751 100644
--- a/util/protogen/internalgengo/proto_field_type.go
+++ b/util/protogen/internalgengo/proto_field_type.go
@@ -43,7 +43,10 @@ func fieldType(g *protogen.GeneratedFile, field *protogen.Field) structField {
 	case protoreflect.BytesKind:
 		typ = "[]byte"
 	case protoreflect.MessageKind:
-		typ = structField(g.QualifiedGoIdent(field.Message.GoIdent)).PointerTo()
+		typ = structField(g.QualifiedGoIdent(field.Message.GoIdent))
+		if !field.Desc.IsList() {
+			typ = typ.PointerTo()
+		}
 	case protoreflect.GroupKind:
 		panic("unimplemented")
 	}
diff --git a/util/protogen/internalgengo/proto_stable_compat.go b/util/protogen/internalgengo/proto_stable_compat.go
index c27b9d8..3c4670c 100644
--- a/util/protogen/internalgengo/proto_stable_compat.go
+++ b/util/protogen/internalgengo/proto_stable_compat.go
@@ -72,7 +72,7 @@ func emitFieldSize(g *protogen.GeneratedFile, f *protogen.Field) {
 	case f.Desc.IsList() && (f.Desc.Kind() == protoreflect.MessageKind || f.Desc.Kind() == protoreflect.Uint64Kind && !f.Desc.IsPacked()):
 		g.P("for i := range ", name, "{")
 		if f.Desc.Kind() == protoreflect.MessageKind {
-			g.P("size += ", protoPackage.Ident("NestedStructureSize"), "(", f.Desc.Number(), ", ", name, "[i])")
+			g.P("size += ", protoPackage.Ident("NestedStructureSizeUnchecked"), "(", f.Desc.Number(), ", &", name, "[i])")
 		} else {
 			if f.Desc.Kind() != protoreflect.Uint64Kind {
 				panic("only uint64 unpacked primitive is supported")