diff --git a/CHANGELOG.md b/CHANGELOG.md
index f51b8863fd..d80d25794d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,6 +29,7 @@ Changelog for NeoFS Node
 - BoltDB from write-cache (#3091)
 
 ### Updated
+- SDK to the post-api-go version (#3103)
 
 ### Updating from v0.44.2
 Using public keys as a rule target in eACL tables was deprecated, and 
diff --git a/cmd/neofs-cli/internal/client/sdk.go b/cmd/neofs-cli/internal/client/sdk.go
index 617910dc7c..3a6172263d 100644
--- a/cmd/neofs-cli/internal/client/sdk.go
+++ b/cmd/neofs-cli/internal/client/sdk.go
@@ -9,8 +9,6 @@ import (
 	"github.com/nspcc-dev/neofs-node/pkg/network"
 	"github.com/nspcc-dev/neofs-sdk-go/client"
 	"github.com/spf13/viper"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
 )
 
 var errInvalidEndpoint = errors.New("provided RPC endpoint is incorrect")
@@ -61,20 +59,7 @@ func GetSDKClient(ctx context.Context, addr network.Address) (*client.Client, er
 		return nil, fmt.Errorf("can't create SDK client: %w", err)
 	}
 
-	if err := c.Dial(prmDial); err != nil { //nolint:contextcheck // SetContext is used above.
-		// Here is a hack helping IR healthcheck to work. Current API client revision
-		// calls NetmapService.EndpointInfo RPC which is a part of the NeoFS API
-		// protocol. Inner ring nodes don't serve NeoFS API services, so they respond
-		// with Unimplemented code. We ignore this error here:
-		//  - if nodes responds, then dial was successful
-		//  - even if we connect to storage node which MUST provide NeoFS API services,
-		//    subsequent EndpointInfo method will return Unimplemented error anyway
-		// This behavior is going to be fixed on SDK side.
-		//
-		// Track https://github.com/nspcc-dev/neofs-node/issues/2477
-		if status.Code(err) == codes.Unimplemented {
-			return c, nil
-		}
+	if err := c.Dial(prmDial); err != nil {
 		return nil, fmt.Errorf("can't init SDK client: %w", err)
 	}
 
diff --git a/cmd/neofs-cli/modules/util/acl.go b/cmd/neofs-cli/modules/util/acl.go
index 414cd0b350..117b32b050 100644
--- a/cmd/neofs-cli/modules/util/acl.go
+++ b/cmd/neofs-cli/modules/util/acl.go
@@ -208,8 +208,8 @@ func parseEACLTable(tb *eacl.Table, args []string) error {
 		return errors.New("at least 2 arguments must be provided")
 	}
 
-	action, ok := eacl.ActionFromString(strings.ToUpper(args[0]))
-	if !ok {
+	var action eacl.Action
+	if !action.DecodeString(strings.ToUpper(args[0])) {
 		return errors.New("invalid action (expected 'allow' or 'deny')")
 	}
 
@@ -348,8 +348,8 @@ func validateDecimal(s string) bool {
 
 // eaclRoleFromString parses eacl.Role from string.
 func eaclRoleFromString(s string) (eacl.Role, error) {
-	r, ok := eacl.RoleFromString(strings.ToUpper(s))
-	if !ok {
+	var r eacl.Role
+	if !r.DecodeString(strings.ToUpper(s)) {
 		return r, fmt.Errorf("unexpected role %s", s)
 	}
 
@@ -377,10 +377,9 @@ func parseAccountList(s string) ([]user.ID, error) {
 func eaclOperationsFromString(s string) ([]eacl.Operation, error) {
 	ss := strings.Split(s, ",")
 	ops := make([]eacl.Operation, len(ss))
-	var ok bool
 
 	for i := range ss {
-		if ops[i], ok = eacl.OperationFromString(strings.ToUpper(ss[i])); !ok {
+		if !ops[i].DecodeString(strings.ToUpper(ss[i])) {
 			return nil, fmt.Errorf("invalid operation: %s", ss[i])
 		}
 	}
diff --git a/cmd/neofs-node/accounting.go b/cmd/neofs-node/accounting.go
index 966902b23e..32df0be621 100644
--- a/cmd/neofs-node/accounting.go
+++ b/cmd/neofs-node/accounting.go
@@ -1,9 +1,9 @@
 package main
 
 import (
-	accountingGRPC "github.com/nspcc-dev/neofs-api-go/v2/accounting/grpc"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/client/balance"
 	accountingService "github.com/nspcc-dev/neofs-node/pkg/services/accounting"
+	protoaccounting "github.com/nspcc-dev/neofs-sdk-go/proto/accounting"
 )
 
 func initAccountingService(c *cfg) {
@@ -17,6 +17,6 @@ func initAccountingService(c *cfg) {
 	server := accountingService.New(&c.key.PrivateKey, c.networkState, balanceMorphWrapper)
 
 	for _, srv := range c.cfgGRPC.servers {
-		accountingGRPC.RegisterAccountingServiceServer(srv, server)
+		protoaccounting.RegisterAccountingServiceServer(srv, server)
 	}
 }
diff --git a/cmd/neofs-node/attributes.go b/cmd/neofs-node/attributes.go
index 988cfc9ce3..5d0199d357 100644
--- a/cmd/neofs-node/attributes.go
+++ b/cmd/neofs-node/attributes.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/nspcc-dev/locode-db/pkg/locodedb"
-	netmapV2 "github.com/nspcc-dev/neofs-api-go/v2/netmap"
 	nodeconfig "github.com/nspcc-dev/neofs-node/cmd/neofs-node/config/node"
 	"github.com/nspcc-dev/neofs-node/pkg/util/attributes"
 	"go.uber.org/zap"
@@ -118,11 +117,3 @@ func nodeAttrsEqual(arr1, arr2 [][2]string) bool {
 
 	return true
 }
-
-func nodeAttrsToSlice(attrs []netmapV2.Attribute) [][2]string {
-	res := make([][2]string, len(attrs))
-	for i := range attrs {
-		res[i] = [2]string{attrs[i].GetKey(), attrs[i].GetValue()}
-	}
-	return res
-}
diff --git a/cmd/neofs-node/container.go b/cmd/neofs-node/container.go
index 37536e02b0..04f955cb27 100644
--- a/cmd/neofs-node/container.go
+++ b/cmd/neofs-node/container.go
@@ -8,13 +8,6 @@ import (
 	"errors"
 	"fmt"
 
-	apicontainer "github.com/nspcc-dev/neofs-api-go/v2/container"
-	protocontainer "github.com/nspcc-dev/neofs-api-go/v2/container/grpc"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	containerrpc "github.com/nspcc-dev/neofs-contract/rpc/container"
 	"github.com/nspcc-dev/neofs-node/pkg/core/client"
 	containerCore "github.com/nspcc-dev/neofs-node/pkg/core/container"
@@ -33,9 +26,13 @@ import (
 	apiClient "github.com/nspcc-dev/neofs-sdk-go/client"
 	containerSDK "github.com/nspcc-dev/neofs-sdk-go/container"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
+	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
 	"github.com/nspcc-dev/neofs-sdk-go/eacl"
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protocontainer "github.com/nspcc-dev/neofs-sdk-go/proto/container"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 	"github.com/nspcc-dev/neofs-sdk-go/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
@@ -517,18 +514,16 @@ func (c *usedSpaceService) ExternalAddresses() []string {
 }
 
 func (c *usedSpaceService) makeResponse(body *protocontainer.AnnounceUsedSpaceResponse_Body, st *protostatus.Status) (*protocontainer.AnnounceUsedSpaceResponse, error) {
-	v := version.Current()
-	var v2 apirefs.Version
-	v.WriteToV2(&v2)
 	resp := &protocontainer.AnnounceUsedSpaceResponse{
 		Body: body,
 		MetaHeader: &protosession.ResponseMetaHeader{
-			Version: v2.ToGRPCMessage().(*refs.Version),
+			Version: version.Current().ProtoMessage(),
 			Epoch:   c.cfg.networkState.CurrentEpoch(),
 			Status:  st,
 		},
 	}
-	return util.SignResponse(&c.cfg.key.PrivateKey, resp, apicontainer.AnnounceUsedSpaceResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(&c.cfg.key.PrivateKey, resp)
+	return resp, nil
 }
 
 func (c *usedSpaceService) makeStatusResponse(err error) (*protocontainer.AnnounceUsedSpaceResponse, error) {
@@ -536,11 +531,7 @@ func (c *usedSpaceService) makeStatusResponse(err error) (*protocontainer.Announ
 }
 
 func (c *usedSpaceService) AnnounceUsedSpace(ctx context.Context, req *protocontainer.AnnounceUsedSpaceRequest) (*protocontainer.AnnounceUsedSpaceResponse, error) {
-	putReq := new(apicontainer.AnnounceUsedSpaceRequest)
-	if err := putReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(putReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return c.makeStatusResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -566,11 +557,7 @@ func (c *usedSpaceService) AnnounceUsedSpace(ctx context.Context, req *protocont
 	var est containerSDK.SizeEstimation
 
 	for _, a := range req.GetBody().GetAnnouncements() {
-		var a2 apicontainer.UsedSpaceAnnouncement
-		if err := a2.FromGRPCMessage(a); err != nil {
-			panic(err)
-		}
-		err = est.ReadFromV2(a2)
+		err = est.FromProtoMessage(a)
 		if err != nil {
 			return c.makeStatusResponse(fmt.Errorf("invalid size announcement: %w", err))
 		}
diff --git a/cmd/neofs-node/netmap.go b/cmd/neofs-node/netmap.go
index 1eaf5c7286..191aed9d09 100644
--- a/cmd/neofs-node/netmap.go
+++ b/cmd/neofs-node/netmap.go
@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	netmapV2 "github.com/nspcc-dev/neofs-api-go/v2/netmap"
-	netmapGRPC "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
 	"github.com/nspcc-dev/neofs-node/pkg/metrics"
 	nmClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
@@ -16,6 +14,7 @@ import (
 	"github.com/nspcc-dev/neofs-node/pkg/services/control"
 	netmapService "github.com/nspcc-dev/neofs-node/pkg/services/netmap"
 	netmapSDK "github.com/nspcc-dev/neofs-sdk-go/netmap"
+	protonetmap "github.com/nspcc-dev/neofs-sdk-go/proto/netmap"
 	"go.uber.org/zap"
 )
 
@@ -172,7 +171,7 @@ func initNetmapService(c *cfg) {
 	server := netmapService.New(&c.key.PrivateKey, c)
 
 	for _, srv := range c.cfgGRPC.servers {
-		netmapGRPC.RegisterNetmapServiceServer(srv, server)
+		protonetmap.RegisterNetmapServiceServer(srv, server)
 	}
 
 	addNewEpochNotificationHandler(c, func(ev event.Event) {
@@ -446,33 +445,22 @@ func (c *cfg) GetNetworkInfo() (netmapSDK.NetworkInfo, error) {
 func (c *cfg) reloadNodeAttributes() error {
 	c.cfgNodeInfo.localInfoLock.Lock()
 
-	// TODO(@End-rey): after updating SDK, rewrite with w/o api netmap. See #3005, neofs-sdk-go#635.
-	var ni2 netmapV2.NodeInfo
-	c.cfgNodeInfo.localInfo.WriteToV2(&ni2)
+	oldAttrs := c.cfgNodeInfo.localInfo.GetAttributes()
 
-	oldAttrs := ni2.GetAttributes()
+	c.cfgNodeInfo.localInfo.SetAttributes(nil)
 
-	ni2.SetAttributes(nil)
-
-	err := c.cfgNodeInfo.localInfo.ReadFromV2(ni2)
-	if err != nil {
-		c.cfgNodeInfo.localInfoLock.Unlock()
-		return err
-	}
-
-	err = writeSystemAttributes(c)
+	err := writeSystemAttributes(c)
 	if err != nil {
 		c.cfgNodeInfo.localInfoLock.Unlock()
 		return err
 	}
 	parseAttributes(c)
 
-	c.cfgNodeInfo.localInfo.WriteToV2(&ni2)
+	newAttrs := c.cfgNodeInfo.localInfo.GetAttributes()
 
-	newAttrs := ni2.GetAttributes()
 	c.cfgNodeInfo.localInfoLock.Unlock()
 
-	if nodeAttrsEqual(nodeAttrsToSlice(oldAttrs), nodeAttrsToSlice(newAttrs)) {
+	if nodeAttrsEqual(oldAttrs, newAttrs) {
 		return nil
 	}
 
diff --git a/cmd/neofs-node/object.go b/cmd/neofs-node/object.go
index 0d20a46397..6fc899fabb 100644
--- a/cmd/neofs-node/object.go
+++ b/cmd/neofs-node/object.go
@@ -10,7 +10,6 @@ import (
 
 	"github.com/google/uuid"
 	lru "github.com/hashicorp/golang-lru/v2"
-	objectGRPC "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
 	replicatorconfig "github.com/nspcc-dev/neofs-node/cmd/neofs-node/config/replicator"
 	coreclient "github.com/nspcc-dev/neofs-node/pkg/core/client"
 	containercore "github.com/nspcc-dev/neofs-node/pkg/core/container"
@@ -39,6 +38,7 @@ import (
 	netmapsdk "github.com/nspcc-dev/neofs-sdk-go/netmap"
 	objectSDK "github.com/nspcc-dev/neofs-sdk-go/object"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
 	apireputation "github.com/nspcc-dev/neofs-sdk-go/reputation"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"go.uber.org/zap"
@@ -309,7 +309,7 @@ func initObjectService(c *cfg) {
 	server := objectService.New(objSvc, mNumber, fsChain, storage, c.shared.basics.key.PrivateKey, c.metricsCollector, aclChecker, aclSvc)
 
 	for _, srv := range c.cfgGRPC.servers {
-		objectGRPC.RegisterObjectServiceServer(srv, server)
+		protoobject.RegisterObjectServiceServer(srv, server)
 	}
 }
 
diff --git a/cmd/neofs-node/reputation.go b/cmd/neofs-node/reputation.go
index 07f92a46fa..50345beaec 100644
--- a/cmd/neofs-node/reputation.go
+++ b/cmd/neofs-node/reputation.go
@@ -4,13 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	v2reputation "github.com/nspcc-dev/neofs-api-go/v2/reputation"
-	protoreputation "github.com/nspcc-dev/neofs-api-go/v2/reputation/grpc"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	"github.com/nspcc-dev/neofs-node/cmd/neofs-node/reputation/common"
 	intermediatereputation "github.com/nspcc-dev/neofs-node/cmd/neofs-node/reputation/intermediate"
 	localreputation "github.com/nspcc-dev/neofs-node/cmd/neofs-node/reputation/local"
@@ -31,6 +24,10 @@ import (
 	localroutes "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/routes"
 	truststorage "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/storage"
 	"github.com/nspcc-dev/neofs-node/pkg/services/util"
+	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
+	protoreputation "github.com/nspcc-dev/neofs-sdk-go/proto/reputation"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 	apireputation "github.com/nspcc-dev/neofs-sdk-go/reputation"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
 	"go.uber.org/zap"
@@ -259,11 +256,8 @@ type reputationServer struct {
 }
 
 func (s *reputationServer) makeResponseMetaHeader(st *protostatus.Status) *protosession.ResponseMetaHeader {
-	v := version.Current()
-	var v2 apirefs.Version
-	v.WriteToV2(&v2)
 	return &protosession.ResponseMetaHeader{
-		Version: v2.ToGRPCMessage().(*refs.Version),
+		Version: version.Current().ProtoMessage(),
 		Epoch:   s.networkState.CurrentEpoch(),
 		Status:  st,
 	}
@@ -273,15 +267,12 @@ func (s *reputationServer) makeLocalResponse(err error) (*protoreputation.Announ
 	resp := &protoreputation.AnnounceLocalTrustResponse{
 		MetaHeader: s.makeResponseMetaHeader(util.ToStatus(err)),
 	}
-	return util.SignResponse(&s.key.PrivateKey, resp, v2reputation.AnnounceLocalTrustResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(&s.key.PrivateKey, resp)
+	return resp, nil
 }
 
 func (s *reputationServer) AnnounceLocalTrust(ctx context.Context, req *protoreputation.AnnounceLocalTrustRequest) (*protoreputation.AnnounceLocalTrustResponse, error) {
-	req2 := new(v2reputation.AnnounceLocalTrustRequest)
-	if err := req2.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(req2); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeLocalResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -314,15 +305,12 @@ func (s *reputationServer) makeIntermediateResponse(err error) (*protoreputation
 	resp := &protoreputation.AnnounceIntermediateResultResponse{
 		MetaHeader: s.makeResponseMetaHeader(util.ToStatus(err)),
 	}
-	return util.SignResponse(&s.key.PrivateKey, resp, v2reputation.AnnounceIntermediateResultResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(&s.key.PrivateKey, resp)
+	return resp, nil
 }
 
 func (s *reputationServer) AnnounceIntermediateResult(ctx context.Context, req *protoreputation.AnnounceIntermediateResultRequest) (*protoreputation.AnnounceIntermediateResultResponse, error) {
-	req2 := new(v2reputation.AnnounceIntermediateResultRequest)
-	if err := req2.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(req2); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeIntermediateResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
diff --git a/cmd/neofs-node/session.go b/cmd/neofs-node/session.go
index 21802c68a1..b0d0c34978 100644
--- a/cmd/neofs-node/session.go
+++ b/cmd/neofs-node/session.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"time"
 
-	sessionGRPC "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	nodeconfig "github.com/nspcc-dev/neofs-node/cmd/neofs-node/config/node"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event/netmap"
@@ -12,6 +11,7 @@ import (
 	"github.com/nspcc-dev/neofs-node/pkg/services/session/storage"
 	"github.com/nspcc-dev/neofs-node/pkg/services/session/storage/persistent"
 	"github.com/nspcc-dev/neofs-node/pkg/services/session/storage/temporary"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 )
 
@@ -50,6 +50,6 @@ func initSessionService(c *cfg) {
 	server := sessionSvc.New(&c.key.PrivateKey, c, c.privateTokenStore)
 
 	for _, srv := range c.cfgGRPC.servers {
-		sessionGRPC.RegisterSessionServiceServer(srv, server)
+		protosession.RegisterSessionServiceServer(srv, server)
 	}
 }
diff --git a/cmd/neofs-node/transport.go b/cmd/neofs-node/transport.go
index efd62526a4..4107e923e7 100644
--- a/cmd/neofs-node/transport.go
+++ b/cmd/neofs-node/transport.go
@@ -2,12 +2,12 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
-	objectGRPC "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/status"
 	coreclient "github.com/nspcc-dev/neofs-node/pkg/core/client"
 	apistatus "github.com/nspcc-dev/neofs-sdk-go/client/status"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/encoding"
 	"google.golang.org/grpc/encoding/proto"
@@ -25,18 +25,16 @@ func (x *transport) SendReplicationRequestToNode(ctx context.Context, req []byte
 		return nil, fmt.Errorf("connect to remote node: %w", err)
 	}
 
-	var resp objectGRPC.ReplicateResponse
-	err = c.ExecRaw(func(conn *grpc.ClientConn) error {
-		// this will be changed during NeoFS API Go deprecation. Code most likely be
-		// placed in SDK
-		err = conn.Invoke(ctx, objectGRPC.ObjectService_Replicate_FullMethodName, req, &resp, binaryMessageOnly)
-		if err != nil {
-			return fmt.Errorf("API transport (op=%s): %w", objectGRPC.ObjectService_Replicate_FullMethodName, err)
-		}
-		return err
-	})
+	var resp protoobject.ReplicateResponse
+	conn := c.Conn()
+	if conn == nil {
+		return nil, errors.New("can't get grpc connection to node")
+	}
+	// this will be changed during NeoFS API Go deprecation. Code most likely be
+	// placed in SDK
+	err = conn.Invoke(ctx, protoobject.ObjectService_Replicate_FullMethodName, req, &resp, binaryMessageOnly)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("API transport (op=%s): %w", protoobject.ObjectService_Replicate_FullMethodName, err)
 	}
 
 	return replicationResultFromResponse(&resp)
@@ -65,17 +63,8 @@ func (protoCodecBinaryRequestOnly) Unmarshal(raw []byte, msg any) error {
 	return encoding.GetCodec(proto.Name).Unmarshal(raw, msg)
 }
 
-func replicationResultFromResponse(m *objectGRPC.ReplicateResponse) ([]byte, error) {
-	var st *status.Status
-	if mst := m.GetStatus(); mst != nil {
-		st = new(status.Status)
-		err := st.FromGRPCMessage(mst)
-		if err != nil {
-			return nil, fmt.Errorf("decode response status: %w", err)
-		}
-	}
-
-	err := apistatus.ErrorFromV2(st)
+func replicationResultFromResponse(m *protoobject.ReplicateResponse) ([]byte, error) {
+	err := apistatus.ToError(m.GetStatus())
 	if err != nil {
 		return nil, err
 	}
diff --git a/go.mod b/go.mod
index 5f8e6ec9ca..14e848fd39 100644
--- a/go.mod
+++ b/go.mod
@@ -13,13 +13,13 @@ require (
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/mr-tron/base58 v1.2.0
 	github.com/multiformats/go-multiaddr v0.12.2
-	github.com/nspcc-dev/hrw/v2 v2.0.1
+	github.com/nspcc-dev/hrw/v2 v2.0.2
 	github.com/nspcc-dev/locode-db v0.6.0
 	github.com/nspcc-dev/neo-go v0.107.1
 	github.com/nspcc-dev/neofs-api-go/v2 v2.14.1-0.20240827150555-5ce597aa14ea
 	github.com/nspcc-dev/neofs-contract v0.20.1-0.20241220193924-4da43dfb5a65
-	github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.12.0.20240809202351-256513c1b29b
-	github.com/nspcc-dev/tzhash v1.8.0
+	github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.12.0.20250130151303-051c6238eaea
+	github.com/nspcc-dev/tzhash v1.8.2
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/panjf2000/ants/v2 v2.9.0
 	github.com/prometheus/client_golang v1.20.2
@@ -34,13 +34,13 @@ require (
 	golang.org/x/sync v0.10.0
 	golang.org/x/sys v0.28.0
 	golang.org/x/term v0.27.0
-	google.golang.org/grpc v1.64.1
+	google.golang.org/grpc v1.65.0
 	google.golang.org/protobuf v1.34.2
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
-	github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20221202181307-76fa05c21b12 // indirect
+	github.com/antlr4-go/antlr/v4 v4.13.1 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.14.2 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
@@ -95,7 +95,7 @@ require (
 	golang.org/x/crypto v0.31.0 // indirect
 	golang.org/x/exp v0.0.0-20240823005443-9b4947da3948 // indirect
 	golang.org/x/text v0.21.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240528184218-531527333157 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	lukechampine.com/blake3 v1.2.1 // indirect
 	rsc.io/tmplfunc v0.0.3 // indirect
diff --git a/go.sum b/go.sum
index 5381814e2e..24f34e5026 100644
--- a/go.sum
+++ b/go.sum
@@ -2,12 +2,10 @@ dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
 dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
 github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
 github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
-github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
-github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
-github.com/Microsoft/hcsshim v0.11.4 h1:68vKo2VN8DE9AdN4tnkWnmdhqdbpUFM8OF3Airm7fz8=
-github.com/Microsoft/hcsshim v0.11.4/go.mod h1:smjE4dvqPX9Zldna+t5FG3rnoHhaB7QYxPRqGcpAD9w=
-github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20221202181307-76fa05c21b12 h1:npHgfD4Tl2WJS3AJaMUi5ynGDPUBfkg3U3fCzDyXZ+4=
-github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20221202181307-76fa05c21b12/go.mod h1:pSwJ0fSY5KhvocuWSx4fz3BA8OrA1bQn+K1Eli3BRwM=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ=
+github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bits-and-blooms/bitset v1.14.2 h1:YXVoyPndbdvcEVcseEovVfp0qjJp7S+i5+xgp/Nfbdc=
@@ -28,10 +26,12 @@ github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/Yj
 github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI=
 github.com/consensys/gnark-crypto v0.14.0 h1:DDBdl4HaBtdQsq/wfMwJvZNE80sHidrK3Nfrefatm0E=
 github.com/consensys/gnark-crypto v0.14.0/go.mod h1:CU4UijNPsHawiVGNxe9co07FkzCeWHHrb1li/n1XoU0=
-github.com/containerd/containerd v1.7.13 h1:wPYKIeGMN8vaggSKuV1X0wZulpMz4CrgEsZdaCyB6Is=
-github.com/containerd/containerd v1.7.13/go.mod h1:zT3up6yTRfEUa6+GsITYIJNgSVL9NQ4x4h1RPzk0Wu4=
+github.com/containerd/containerd v1.7.18 h1:jqjZTQNfXGoEaZdW1WwPU0RqSn1Bm2Ay/KJPUuO8nao=
+github.com/containerd/containerd v1.7.18/go.mod h1:IYEk9/IO6wAPUz2bCMVUbsfXjzw5UNP5fLz4PsUygQ4=
 github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
 github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
+github.com/containerd/platforms v0.2.1 h1:zvwtM3rz2YHPQsF2CHYM8+KtB5dvhISiXh5ZpSBQv6A=
+github.com/containerd/platforms v0.2.1/go.mod h1:XHCb+2/hzowdiut9rkudds9bE5yJ7npe7dG/wG+uFPw=
 github.com/cpuguy83/dockercfg v0.3.1 h1:/FpZ+JaygUR/lZP2NlFI2DVfrOEMAIKP5wWEJdoYe9E=
 github.com/cpuguy83/dockercfg v0.3.1/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc=
 github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
@@ -42,17 +42,19 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
-github.com/docker/distribution v2.8.2+incompatible h1:T3de5rq0dB1j30rp0sA2rER+m322EBzniBPB6ZIzuh8=
-github.com/docker/distribution v2.8.2+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
-github.com/docker/docker v24.0.9+incompatible h1:HPGzNmwfLZWdxHqK9/II92pyi1EpYKsAqcl4G0Of9v0=
-github.com/docker/docker v24.0.9+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ=
-github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
+github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
+github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
+github.com/docker/docker v27.1.1+incompatible h1:hO/M4MtV36kzKldqnA37IWhebRA+LnqqcqDja6kVaKY=
+github.com/docker/docker v27.1.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
+github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
 github.com/fatih/color v1.14.1 h1:qfhVLaG5s+nCROl1zJsZRxFeYrHLqWroPOQ8BWiNb4w=
 github.com/fatih/color v1.14.1/go.mod h1:2oHN61fhTpgcxD3TSWCgKDiH1+x4OiDVVGH8WlgGZGg=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BMXYYRWTLOJKlh+lOBt6nUQgXAfB7oVIQt5cNreqSLI=
 github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:rZfgFAXFS/z/lEd6LJmf9HVZ1LkgYiHx5pHhV5DR16M=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
@@ -61,6 +63,10 @@ github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMo
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
 github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
@@ -140,10 +146,14 @@ github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RR
 github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY=
 github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU=
 github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU=
-github.com/moby/patternmatcher v0.5.0 h1:YCZgJOeULcxLw1Q+sVR636pmS7sPEn1Qo2iAN6M7DBo=
-github.com/moby/patternmatcher v0.5.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
+github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
+github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk=
+github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
 github.com/moby/sys/sequential v0.5.0 h1:OPvI35Lzn9K04PBbCLW0g4LcFAJgHsvXsRyewg5lXtc=
 github.com/moby/sys/sequential v0.5.0/go.mod h1:tH2cOOs5V9MlPiXcQzRC+eEyab644PWKGRYaaV5ZZlo=
+github.com/moby/sys/user v0.1.0 h1:WmZ93f5Ux6het5iituh9x2zAG7NFY9Aqi49jjE1PaQg=
+github.com/moby/sys/user v0.1.0/go.mod h1:fKJhFOnsCN6xZ5gSfbM6zaHGgDJMrqt9/reuj4T7MmU=
 github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
 github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
 github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
@@ -168,8 +178,8 @@ github.com/nspcc-dev/dbft v0.3.1 h1:3qoc65CVJMtdL/627JZH+1Jz839LmdsVN52L4mlP5z8=
 github.com/nspcc-dev/dbft v0.3.1/go.mod h1:BNvJkPKTE28r+qRaAk2C3VoL2J9qzox3fvEeJbh7EWE=
 github.com/nspcc-dev/go-ordered-json v0.0.0-20240830112754-291b000d1f3b h1:DRG4cRqIOmI/nUPggMgR92Jxt63Lxsuz40m5QpdvYXI=
 github.com/nspcc-dev/go-ordered-json v0.0.0-20240830112754-291b000d1f3b/go.mod h1:d3cUseu4Asxfo9/QA/w4TtGjM0AbC9ynyab+PfH+Bso=
-github.com/nspcc-dev/hrw/v2 v2.0.1 h1:CxYUkBeJvNfMEn2lHhrV6FjY8pZPceSxXUtMVq0BUOU=
-github.com/nspcc-dev/hrw/v2 v2.0.1/go.mod h1:iZAs5hT2q47EGq6AZ0FjaUI6ggntOi7vrY4utfzk5VA=
+github.com/nspcc-dev/hrw/v2 v2.0.2 h1:Vuc2Yu96MCv1YDUjErMuCt5tq+g/43/Y89u/XfyLkRI=
+github.com/nspcc-dev/hrw/v2 v2.0.2/go.mod h1:XRsG20axGJfr0Ytcau/UcZ/9NF54RmUIqmoYKuuliSo=
 github.com/nspcc-dev/locode-db v0.6.0 h1:EdRUug+sL0EMLZgucLETD6bnegKjyEZh+D5x4r5VMvY=
 github.com/nspcc-dev/locode-db v0.6.0/go.mod h1:mJLXdzlcRucr3AFUvf5fJH+rFv1bJuU85e1jtDHDTz8=
 github.com/nspcc-dev/neo-go v0.107.1 h1:Mef1nLhYj96G6nX8uxKh1tIXFk4PbxgRwOAGAtUsuTY=
@@ -180,12 +190,12 @@ github.com/nspcc-dev/neofs-api-go/v2 v2.14.1-0.20240827150555-5ce597aa14ea h1:mK
 github.com/nspcc-dev/neofs-api-go/v2 v2.14.1-0.20240827150555-5ce597aa14ea/go.mod h1:YzhD4EZmC9Z/PNyd7ysC7WXgIgURc9uCG1UWDeV027Y=
 github.com/nspcc-dev/neofs-contract v0.20.1-0.20241220193924-4da43dfb5a65 h1:SruyrmzfmaIK+rx3EyLsG3hb9Ooh+cTkObucl0yTVxY=
 github.com/nspcc-dev/neofs-contract v0.20.1-0.20241220193924-4da43dfb5a65/go.mod h1:fwM6QoYPnsIuUQ4/GOwgzfQ9qoDKknqYgf4XWOqEdJw=
-github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.12.0.20240809202351-256513c1b29b h1:/7jXQP5pf+M0kRFC1gg5GEdTPkvotpMHxjSXIbMZaGQ=
-github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.12.0.20240809202351-256513c1b29b/go.mod h1:ewV84r1NACvoBfbKQKzRLUun+Xn5+z9JVqsuCVgv9xI=
+github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.12.0.20250130151303-051c6238eaea h1:la9jMy0nzHs+j7qkgvgiL8DmePSyRYXlQa6XqmMR5qo=
+github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.12.0.20250130151303-051c6238eaea/go.mod h1:Hd0zRo7mfGDf/S+yGPnRi9eWipxJNhec2Oik1w7lwQo=
 github.com/nspcc-dev/rfc6979 v0.2.3 h1:QNVykGZ3XjFwM/88rGfV3oj4rKNBy+nYI6jM7q19hDI=
 github.com/nspcc-dev/rfc6979 v0.2.3/go.mod h1:q3sCL1Ed7homjqYK8KmFSzEmm+7Ngyo7PePbZanhaDE=
-github.com/nspcc-dev/tzhash v1.8.0 h1:pJvzME2mZzP/h5rcy/Wb6amT9FJBFeKbJ3HEnWEeUpY=
-github.com/nspcc-dev/tzhash v1.8.0/go.mod h1:oHiH0qwmTsZkeVs7pvCS5cVXUaLhXxSFvnmnZ++ijm4=
+github.com/nspcc-dev/tzhash v1.8.2 h1:ebRCbPoEuoqrhC6sSZmrT/jI3h1SzCWakxxV6gp5QAg=
+github.com/nspcc-dev/tzhash v1.8.2/go.mod h1:SFwvvB1KyKm45vdWpcOCFpklkUEsXtddnHsk+zq298g=
 github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
@@ -199,10 +209,8 @@ github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
-github.com/opencontainers/image-spec v1.1.0-rc6 h1:XDqvyKsJEbRtATzkgItUqBA7QHk58yxX1Ov9HERHNqU=
-github.com/opencontainers/image-spec v1.1.0-rc6/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
-github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss=
-github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8=
+github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
+github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
 github.com/panjf2000/ants/v2 v2.9.0 h1:SztCLkVxBRigbg+vt0S5QvF5vxAbxbKt09/YfAJ0tEo=
 github.com/panjf2000/ants/v2 v2.9.0/go.mod h1:7ZxyxsqE4vvW0M7LSD8aI3cKwgFhBHbxnlN8mDqHa1I=
 github.com/pelletier/go-toml/v2 v2.1.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
@@ -235,8 +243,8 @@ github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6ke
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
-github.com/shirou/gopsutil/v3 v3.23.7 h1:C+fHO8hfIppoJ1WdsVm1RoI0RwXoNdfTK7yWXV0wVj4=
-github.com/shirou/gopsutil/v3 v3.23.7/go.mod h1:c4gnmoRC0hQuaLqvxnx1//VXQ0Ms/X9UnJF8pddY5z4=
+github.com/shirou/gopsutil/v3 v3.23.12 h1:z90NtUkp3bMtmICZKpC4+WaknU1eXtp5vtbQ11DgpE4=
+github.com/shirou/gopsutil/v3 v3.23.12/go.mod h1:1FrWgea594Jp7qmjHUUPlJDTPgcsb9mGnXDxavtikzM=
 github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
 github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
@@ -268,12 +276,12 @@ github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/syndtr/goleveldb v1.0.1-0.20210305035536-64b5b1c73954 h1:xQdMZ1WLrgkkvOZ/LDQxjVxMLdby7osSh4ZEVa5sIjs=
 github.com/syndtr/goleveldb v1.0.1-0.20210305035536-64b5b1c73954/go.mod h1:u2MKkTVTVJWe5D1rCvame8WqhBd88EuIwODJZ1VHCPM=
-github.com/testcontainers/testcontainers-go v0.24.1 h1:gJdZuQIVWnMJTo+CmQMEP7/CAagNk/0jbcUPn3OWvD8=
-github.com/testcontainers/testcontainers-go v0.24.1/go.mod h1:MGBiAkCm86yXQoCiipmQCqZLVdk1uFqtMqaU1Or0MRk=
-github.com/tklauser/go-sysconf v0.3.11 h1:89WgdJhk5SNwJfu+GKyYveZ4IaJ7xAkecBo+KdJV0CM=
-github.com/tklauser/go-sysconf v0.3.11/go.mod h1:GqXfhXY3kiPa0nAXPDIQIWzJbMCB7AmcWpGR8lSZfqI=
-github.com/tklauser/numcpus v0.6.0 h1:kebhY2Qt+3U6RNK7UqpYNA+tJ23IBEGKkB7JQBfDYms=
-github.com/tklauser/numcpus v0.6.0/go.mod h1:FEZLMke0lhOUG6w2JadTzp0a+Nl8PF/GFkQ5UVIcaL4=
+github.com/testcontainers/testcontainers-go v0.33.0 h1:zJS9PfXYT5O0ZFXM2xxXfk4J5UMw/kRiISng037Gxdw=
+github.com/testcontainers/testcontainers-go v0.33.0/go.mod h1:W80YpTa8D5C3Yy16icheD01UTDu+LmXIA2Keo+jWtT8=
+github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU=
+github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
+github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
+github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
 github.com/twmb/murmur3 v1.1.8 h1:8Yt9taO/WN3l08xErzjeschgZU2QSrwm1kclYq+0aRg=
 github.com/twmb/murmur3 v1.1.8/go.mod h1:Qq/R7NUyOfr65zD+6Q5IHKsJLwP7exErjN6lyyq3OSQ=
 github.com/urfave/cli/v2 v2.27.4 h1:o1owoI+02Eb+K107p27wEX9Bb8eqIoZCfLXloLUSWJ8=
@@ -284,6 +292,14 @@ github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFi
 github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.etcd.io/bbolt v1.3.11 h1:yGEzV1wPz2yVCLsD8ZAiGHhHVlczyC9d1rP43/VCRJ0=
 go.etcd.io/bbolt v1.3.11/go.mod h1:dksAq7YMXoljX0xu6VF5DMZGbhYYoLUalEiSySYAS4I=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw=
+go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
+go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
+go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco=
+go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
+go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
@@ -345,10 +361,10 @@ golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
 google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 h1:NnYq6UN9ReLM9/Y01KWNOWyI5xQ9kbIms5GGJVwS/Yc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY=
-google.golang.org/grpc v1.64.1 h1:LKtvyfbX3UGVPFcGqJ9ItpVWW6oN/2XqTxfAnwRRXiA=
-google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240528184218-531527333157 h1:Zy9XzmMEflZ/MAaA7vNcoebnRAld7FsPW1EeBB7V0m8=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240528184218-531527333157/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0=
+google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
+google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
diff --git a/pkg/core/client/client.go b/pkg/core/client/client.go
index 285a7d357b..ba08d0da42 100644
--- a/pkg/core/client/client.go
+++ b/pkg/core/client/client.go
@@ -21,7 +21,7 @@ import (
 type Client interface {
 	ContainerAnnounceUsedSpace(ctx context.Context, announcements []container.SizeEstimation, prm client.PrmAnnounceSpace) error
 	ObjectPutInit(ctx context.Context, header object.Object, signer user.Signer, prm client.PrmObjectPutInit) (client.ObjectWriter, error)
-	ReplicateObject(ctx context.Context, id oid.ID, src io.ReadSeeker, signer neofscrypto.Signer) error
+	ReplicateObject(ctx context.Context, id oid.ID, src io.ReadSeeker, signer neofscrypto.Signer, signedReplication bool) (*neofscrypto.Signature, error)
 	ObjectDelete(ctx context.Context, containerID cid.ID, objectID oid.ID, signer user.Signer, prm client.PrmObjectDelete) (oid.ID, error)
 	ObjectGetInit(ctx context.Context, containerID cid.ID, objectID oid.ID, signer user.Signer, prm client.PrmObjectGet) (object.Object, *client.PayloadReader, error)
 	ObjectHead(ctx context.Context, containerID cid.ID, objectID oid.ID, signer user.Signer, prm client.PrmObjectHead) (*object.Object, error)
@@ -30,7 +30,7 @@ type Client interface {
 	ObjectHash(ctx context.Context, containerID cid.ID, objectID oid.ID, signer user.Signer, prm client.PrmObjectHash) ([][]byte, error)
 	AnnounceLocalTrust(ctx context.Context, epoch uint64, trusts []reputationSDK.Trust, prm client.PrmAnnounceLocalTrust) error
 	AnnounceIntermediateTrust(ctx context.Context, epoch uint64, trust reputationSDK.PeerToPeerTrust, prm client.PrmAnnounceIntermediateTrust) error
-	ExecRaw(f func(*grpc.ClientConn) error) error
+	Conn() *grpc.ClientConn
 	Close() error
 }
 
diff --git a/pkg/core/object/fmt.go b/pkg/core/object/fmt.go
index a771e68188..a1f220cadb 100644
--- a/pkg/core/object/fmt.go
+++ b/pkg/core/object/fmt.go
@@ -134,12 +134,7 @@ func (v *FormatValidator) Validate(obj *object.Object, unprepared bool) error {
 		} else {
 			// V2 split
 
-			if !firstSet {
-				// first part only
-				if obj.Parent() == nil {
-					return errors.New("v2 split: first object part does not have parent header")
-				}
-			} else {
+			if firstSet {
 				// 2nd+ parts
 
 				typ := obj.Type()
diff --git a/pkg/core/object/fmt_test.go b/pkg/core/object/fmt_test.go
index 51f8ead1fa..ac2d401340 100644
--- a/pkg/core/object/fmt_test.go
+++ b/pkg/core/object/fmt_test.go
@@ -366,13 +366,6 @@ func TestLinkObjectSplitV2(t *testing.T) {
 	})
 
 	t.Run("V2 split", func(t *testing.T) {
-		obj.ResetRelations()
-		obj.SetParent(object.New())
-
-		t.Run("first object is not set", func(t *testing.T) {
-			require.ErrorContains(t, v.Validate(obj, true), "first object part does not have parent header")
-		})
-
 		t.Run("link object without finished parent", func(t *testing.T) {
 			obj.ResetRelations()
 			obj.SetParent(object.New())
diff --git a/pkg/innerring/processors/netmap/process_cleanup.go b/pkg/innerring/processors/netmap/process_cleanup.go
index e9fca27706..491b790de3 100644
--- a/pkg/innerring/processors/netmap/process_cleanup.go
+++ b/pkg/innerring/processors/netmap/process_cleanup.go
@@ -2,7 +2,7 @@ package netmap
 
 import (
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	v2netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap"
+	protonetmap "github.com/nspcc-dev/neofs-sdk-go/proto/netmap"
 	"go.uber.org/zap"
 )
 
@@ -35,7 +35,7 @@ func (np *Processor) processNetmapCleanupTick(ev netmapCleanupTick) {
 			uint32(ev.epoch),
 			nil,
 			methodUpdateStateNotary,
-			int64(v2netmap.Offline), key.Bytes(),
+			int64(protonetmap.NodeInfo_OFFLINE), key.Bytes(),
 		)
 		if err != nil {
 			np.log.Error("can't invoke netmap.UpdateState", zap.Error(err))
diff --git a/pkg/local_object_storage/metabase/select.go b/pkg/local_object_storage/metabase/select.go
index ca15ca1ab9..372523bc86 100644
--- a/pkg/local_object_storage/metabase/select.go
+++ b/pkg/local_object_storage/metabase/select.go
@@ -202,11 +202,11 @@ func (db *DB) selectFastFilter(
 }
 
 var mBucketNaming = map[string][]func(cid.ID, []byte) []byte{
-	object.TypeRegular.EncodeToString():      {primaryBucketName, parentBucketName},
-	object.TypeTombstone.EncodeToString():    {tombstoneBucketName},
-	object.TypeStorageGroup.EncodeToString(): {storageGroupBucketName},
-	object.TypeLock.EncodeToString():         {bucketNameLockers},
-	object.TypeLink.EncodeToString():         {linkObjectsBucketName},
+	object.TypeRegular.String():      {primaryBucketName, parentBucketName},
+	object.TypeTombstone.String():    {tombstoneBucketName},
+	object.TypeStorageGroup.String(): {storageGroupBucketName},
+	object.TypeLock.String():         {bucketNameLockers},
+	object.TypeLink.String():         {linkObjectsBucketName},
 }
 
 func allBucketNames(cnr cid.ID) (names [][]byte) {
diff --git a/pkg/local_object_storage/metabase/select_test.go b/pkg/local_object_storage/metabase/select_test.go
index 4a7bd7e413..8f20df6fd5 100644
--- a/pkg/local_object_storage/metabase/select_test.go
+++ b/pkg/local_object_storage/metabase/select_test.go
@@ -166,7 +166,6 @@ func TestDB_SelectRootPhyParent(t *testing.T) {
 	firstChild := oidtest.ID()
 
 	leftChild := generateObjectWithCID(t, cnr)
-	leftChild.InitRelations()
 	leftChild.SetFirstID(firstChild)
 	err = putBig(db, leftChild)
 	require.NoError(t, err)
diff --git a/pkg/local_object_storage/shard/reload_test.go b/pkg/local_object_storage/shard/reload_test.go
index 35ea63c841..348530ec38 100644
--- a/pkg/local_object_storage/shard/reload_test.go
+++ b/pkg/local_object_storage/shard/reload_test.go
@@ -14,7 +14,6 @@ import (
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
 	objectSDK "github.com/nspcc-dev/neofs-sdk-go/object"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
-	sessiontest "github.com/nspcc-dev/neofs-sdk-go/session/test"
 	usertest "github.com/nspcc-dev/neofs-sdk-go/user/test"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
 	"github.com/stretchr/testify/require"
@@ -128,11 +127,9 @@ func newObject(t testing.TB) *objectSDK.Object {
 	ver := version.Current()
 
 	x.SetID(oidtest.ID())
-	tok := sessiontest.Object()
-	x.SetSessionToken(&tok)
+	owner := usertest.ID()
 	x.SetPayload([]byte{1, 2, 3})
 	x.SetPayloadSize(3)
-	owner := usertest.ID()
 	x.SetOwnerID(&owner)
 	x.SetContainerID(cidtest.ID())
 	x.SetType(objectSDK.TypeRegular)
diff --git a/pkg/network/cache/multi.go b/pkg/network/cache/multi.go
index 28a962c361..2998cf035d 100644
--- a/pkg/network/cache/multi.go
+++ b/pkg/network/cache/multi.go
@@ -8,7 +8,6 @@ import (
 	"sync"
 	"time"
 
-	rawclient "github.com/nspcc-dev/neofs-api-go/v2/rpc/client"
 	clientcore "github.com/nspcc-dev/neofs-node/pkg/core/client"
 	"github.com/nspcc-dev/neofs-node/pkg/network"
 	"github.com/nspcc-dev/neofs-sdk-go/client"
@@ -61,16 +60,6 @@ type clientWrapper struct {
 	*client.Client
 }
 
-func (x clientWrapper) ExecRaw(f func(*grpc.ClientConn) error) error {
-	return x.Client.ExecRaw(func(c *rawclient.Client) error {
-		conn := c.Conn()
-		if conn == nil {
-			return errors.New("missing conn")
-		}
-		return f(conn.(*grpc.ClientConn))
-	})
-}
-
 func (x *multiClient) createForAddress(addr network.Address) (clientcore.Client, error) {
 	var (
 		prmInit client.PrmInit
@@ -254,10 +243,12 @@ func (x *multiClient) ObjectPutInit(ctx context.Context, header objectSDK.Object
 	return
 }
 
-func (x *multiClient) ReplicateObject(ctx context.Context, id oid.ID, src io.ReadSeeker, signer neofscrypto.Signer) error {
+func (x *multiClient) ReplicateObject(ctx context.Context, id oid.ID, src io.ReadSeeker, signer neofscrypto.Signer, signedReplication bool) (*neofscrypto.Signature, error) {
 	var errSeek error
+	var signature *neofscrypto.Signature
 	err := x.iterateClients(ctx, func(c clientcore.Client) error {
-		err := c.ReplicateObject(ctx, id, src, signer)
+		var err error
+		signature, err = c.ReplicateObject(ctx, id, src, signer, signedReplication)
 		if err != nil {
 			_, errSeek = src.Seek(0, io.SeekStart)
 			if errSeek != nil {
@@ -267,9 +258,9 @@ func (x *multiClient) ReplicateObject(ctx context.Context, id oid.ID, src io.Rea
 		return err
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
-	return errSeek
+	return signature, errSeek
 }
 
 func (x *multiClient) ContainerAnnounceUsedSpace(ctx context.Context, announcements []container.SizeEstimation, prm client.PrmAnnounceSpace) error {
@@ -344,12 +335,6 @@ func (x *multiClient) AnnounceIntermediateTrust(ctx context.Context, epoch uint6
 	})
 }
 
-func (x *multiClient) ExecRaw(f func(*grpc.ClientConn) error) error {
-	return x.iterateClients(context.Background(), func(c clientcore.Client) error {
-		return c.ExecRaw(f)
-	})
-}
-
 func (x *multiClient) Close() error {
 	x.mtx.RLock()
 
@@ -372,13 +357,23 @@ func (x *multiClient) RawForAddress(addr network.Address, f func(*grpc.ClientCon
 		return err
 	}
 
-	err = c.ExecRaw(f)
+	err = f(c.Conn())
 	if err != nil {
 		x.ReportError(err)
 	}
 	return err
 }
 
+func (x *multiClient) Conn() *grpc.ClientConn {
+	var cc *grpc.ClientConn
+
+	_ = x.iterateClients(context.TODO(), func(c clientcore.Client) error {
+		cc = c.Conn()
+		return nil
+	})
+	return cc
+}
+
 func (x *multiClient) client(addr network.Address) (clientcore.Client, error) {
 	strAddr := addr.String()
 
diff --git a/pkg/services/accounting/server.go b/pkg/services/accounting/server.go
index ce49ca932d..5fa1fbab0d 100644
--- a/pkg/services/accounting/server.go
+++ b/pkg/services/accounting/server.go
@@ -7,15 +7,12 @@ import (
 	"fmt"
 	"math/big"
 
-	apiaccounting "github.com/nspcc-dev/neofs-api-go/v2/accounting"
-	protoaccounting "github.com/nspcc-dev/neofs-api-go/v2/accounting/grpc"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/services/util"
+	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
+	protoaccounting "github.com/nspcc-dev/neofs-sdk-go/proto/accounting"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
 )
@@ -50,18 +47,16 @@ func New(s *ecdsa.PrivateKey, net netmap.State, c BalanceContract) protoaccounti
 }
 
 func (s *server) makeBalanceResponse(body *protoaccounting.BalanceResponse_Body, st *protostatus.Status) (*protoaccounting.BalanceResponse, error) {
-	v := version.Current()
-	var v2 apirefs.Version
-	v.WriteToV2(&v2)
 	resp := &protoaccounting.BalanceResponse{
 		Body: body,
 		MetaHeader: &protosession.ResponseMetaHeader{
-			Version: v2.ToGRPCMessage().(*refs.Version),
+			Version: version.Current().ProtoMessage(),
 			Epoch:   s.net.CurrentEpoch(),
 			Status:  st,
 		},
 	}
-	return util.SignResponse(s.signer, resp, apiaccounting.BalanceResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeFailedBalanceResponse(err error) (*protoaccounting.BalanceResponse, error) {
@@ -71,11 +66,7 @@ func (s *server) makeFailedBalanceResponse(err error) (*protoaccounting.BalanceR
 // Balance gets current balance of the requested user using underlying
 // [BalanceContract] and returns result in the response.
 func (s *server) Balance(_ context.Context, req *protoaccounting.BalanceRequest) (*protoaccounting.BalanceResponse, error) {
-	balReq := new(apiaccounting.BalanceRequest)
-	if err := balReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(balReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeFailedBalanceResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -83,12 +74,8 @@ func (s *server) Balance(_ context.Context, req *protoaccounting.BalanceRequest)
 	if mUsr == nil {
 		return s.makeFailedBalanceResponse(errors.New("missing account"))
 	}
-	var id2 apirefs.OwnerID
-	if err := id2.FromGRPCMessage(mUsr); err != nil {
-		panic(err)
-	}
 	var id user.ID
-	if err := id.ReadFromV2(id2); err != nil {
+	if err := id.FromProtoMessage(mUsr); err != nil {
 		return s.makeFailedBalanceResponse(fmt.Errorf("invalid account: %w", err))
 	}
 
diff --git a/pkg/services/audit/result.go b/pkg/services/audit/result.go
index 20c7bc5e68..f7b44b10ef 100644
--- a/pkg/services/audit/result.go
+++ b/pkg/services/audit/result.go
@@ -4,11 +4,12 @@ import (
 	"errors"
 	"fmt"
 
-	apiaudit "github.com/nspcc-dev/neofs-api-go/v2/audit"
-	"github.com/nspcc-dev/neofs-api-go/v2/refs"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protoaudit "github.com/nspcc-dev/neofs-sdk-go/proto/audit"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
+	"google.golang.org/protobuf/proto"
 )
 
 // Result groups results of the data audit performed by the Inner Ring member.
@@ -74,42 +75,43 @@ func NewResult(auditorPubKey []byte, epoch uint64, cnr cid.ID) Result {
 func (r Result) Marshal() []byte {
 	var ver *refs.Version
 	if r.versionSet {
-		ver = new(refs.Version)
-		r.version.WriteToV2(ver)
+		ver = r.version.ProtoMessage()
 	}
-	cnr := new(refs.ContainerID)
-	r.Container.WriteToV2(cnr)
-	var passSG []refs.ObjectID
+	cnr := r.Container.ProtoMessage()
+	var passSG []*refs.ObjectID
 	if r.PoR.PassedStorageGroups != nil {
-		passSG = make([]refs.ObjectID, len(r.PoR.PassedStorageGroups))
+		passSG = make([]*refs.ObjectID, len(r.PoR.PassedStorageGroups))
 		for i := range r.PoR.PassedStorageGroups {
-			r.PoR.PassedStorageGroups[i].WriteToV2(&passSG[i])
+			passSG[i] = r.PoR.PassedStorageGroups[i].ProtoMessage()
 		}
 	}
-	var failSG []refs.ObjectID
+	var failSG []*refs.ObjectID
 	if r.PoR.FailedStorageGroups != nil {
-		failSG = make([]refs.ObjectID, len(r.PoR.FailedStorageGroups))
+		failSG = make([]*refs.ObjectID, len(r.PoR.FailedStorageGroups))
 		for i := range r.PoR.FailedStorageGroups {
-			r.PoR.FailedStorageGroups[i].WriteToV2(&failSG[i])
+			failSG[i] = r.PoR.FailedStorageGroups[i].ProtoMessage()
 		}
 	}
-	var m apiaudit.DataAuditResult
-	m.SetVersion(ver)
-	m.SetContainerID(cnr)
-	m.SetAuditEpoch(r.AuditEpoch)
-	m.SetPublicKey(r.AuditorPublicKey)
-	m.SetComplete(r.Completed)
-	m.SetRequests(r.PoR.Requests)
-	m.SetRetries(r.PoR.Retries)
-	m.SetPassSG(passSG)
-	m.SetFailSG(failSG)
-	m.SetHit(r.PoP.Hits)
-	m.SetMiss(r.PoP.Misses)
-	m.SetFail(r.PoP.Failures)
-	m.SetPassNodes(r.PDP.PassedStorageNodes)
-	m.SetFailNodes(r.PDP.FailedStorageNodes)
+	var m = protoaudit.DataAuditResult{
+		Version:     ver,
+		ContainerId: cnr,
+		AuditEpoch:  r.AuditEpoch,
+		PublicKey:   r.AuditorPublicKey,
+		Complete:    r.Completed,
+		Requests:    r.PoR.Requests,
+		Retries:     r.PoR.Retries,
+		PassSg:      passSG,
+		FailSg:      failSG,
+		Hit:         r.PoP.Hits,
+		Miss:        r.PoP.Misses,
+		Fail:        r.PoP.Failures,
+		PassNodes:   r.PDP.PassedStorageNodes,
+		FailNodes:   r.PDP.FailedStorageNodes,
+	}
 
-	return m.StableMarshal(nil)
+	var b = make([]byte, m.MarshaledSize())
+	m.MarshalStable(b)
+	return b
 }
 
 // Unmarshal decodes Protocol Buffers V3 binary data into the Result. Returns an
@@ -117,38 +119,36 @@ func (r Result) Marshal() []byte {
 // not check presence of the required fields and, at the same time, checks
 // format of the presented ones.
 func (r *Result) Unmarshal(data []byte) error {
-	var m apiaudit.DataAuditResult
-	if err := m.Unmarshal(data); err != nil {
+	var m protoaudit.DataAuditResult
+	if err := proto.Unmarshal(data, &m); err != nil {
 		return fmt.Errorf("decode protobuf: %w", err)
 	}
 
-	if cnr := m.GetContainerID(); cnr == nil {
+	if m.ContainerId == nil {
 		return errors.New("missing container")
-	} else if err := r.Container.ReadFromV2(*cnr); err != nil {
+	} else if err := r.Container.FromProtoMessage(m.ContainerId); err != nil {
 		return fmt.Errorf("invalid container: %w", err)
 	}
-	ver := m.GetVersion()
-	if r.versionSet = ver != nil; r.versionSet {
-		if err := r.version.ReadFromV2(*ver); err != nil {
+	r.versionSet = m.Version != nil
+	if r.versionSet {
+		if err := r.version.FromProtoMessage(m.Version); err != nil {
 			return fmt.Errorf("invalid protocol version: %w", err)
 		}
 	}
-	passSG := m.GetPassSG()
-	if len(passSG) > 0 {
-		r.PoR.PassedStorageGroups = make([]oid.ID, len(passSG))
-		for i := range passSG {
-			if err := r.PoR.PassedStorageGroups[i].ReadFromV2(passSG[i]); err != nil {
+	if len(m.PassSg) > 0 {
+		r.PoR.PassedStorageGroups = make([]oid.ID, len(m.PassSg))
+		for i := range m.PassSg {
+			if err := r.PoR.PassedStorageGroups[i].FromProtoMessage(m.PassSg[i]); err != nil {
 				return fmt.Errorf("invalid passed storage group #%d: %w", i, err)
 			}
 		}
 	} else {
 		r.PoR.PassedStorageGroups = nil
 	}
-	failSG := m.GetFailSG()
-	if len(failSG) > 0 {
-		r.PoR.FailedStorageGroups = make([]oid.ID, len(failSG))
-		for i := range failSG {
-			if err := r.PoR.FailedStorageGroups[i].ReadFromV2(failSG[i]); err != nil {
+	if len(m.FailSg) > 0 {
+		r.PoR.FailedStorageGroups = make([]oid.ID, len(m.FailSg))
+		for i := range m.FailSg {
+			if err := r.PoR.FailedStorageGroups[i].FromProtoMessage(m.FailSg[i]); err != nil {
 				return fmt.Errorf("invalid failed storage group #%d: %w", i, err)
 			}
 		}
diff --git a/pkg/services/audit/result_test.go b/pkg/services/audit/result_test.go
index d6f7eb6c94..6a11dd5be7 100644
--- a/pkg/services/audit/result_test.go
+++ b/pkg/services/audit/result_test.go
@@ -5,13 +5,14 @@ import (
 	"math/rand/v2"
 	"testing"
 
-	apiaudit "github.com/nspcc-dev/neofs-api-go/v2/audit"
-	"github.com/nspcc-dev/neofs-api-go/v2/refs"
 	"github.com/nspcc-dev/neofs-node/pkg/services/audit"
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
+	protoaudit "github.com/nspcc-dev/neofs-sdk-go/proto/audit"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
 )
 
 func anyValidAuditResult() audit.Result {
@@ -20,19 +21,21 @@ func anyValidAuditResult() audit.Result {
 
 func TestResultProtocolVersion(t *testing.T) {
 	r := anyValidAuditResult()
-	var msg apiaudit.DataAuditResult
+	var msg protoaudit.DataAuditResult
 
-	require.NoError(t, msg.Unmarshal(r.Marshal()))
+	require.NoError(t, proto.Unmarshal(r.Marshal(), &msg))
 	ver := msg.GetVersion()
 	require.EqualValues(t, 2, ver.GetMajor())
 	require.EqualValues(t, 16, ver.GetMinor())
 
-	ver.SetMajor(100)
-	ver.SetMinor(500)
-	msg.SetVersion(ver)
-	require.NoError(t, r.Unmarshal(msg.StableMarshal(nil)))
-	var msg2 apiaudit.DataAuditResult
-	require.NoError(t, msg2.Unmarshal(r.Marshal()))
+	ver.Major = 100
+	ver.Minor = 500
+	msg.Version = ver
+	b := make([]byte, msg.MarshaledSize())
+	msg.MarshalStable(b)
+	require.NoError(t, r.Unmarshal(b))
+	var msg2 protoaudit.DataAuditResult
+	require.NoError(t, proto.Unmarshal(b, &msg2))
 	ver = msg.GetVersion()
 	require.EqualValues(t, 100, ver.GetMajor())
 	require.EqualValues(t, 500, ver.GetMinor())
@@ -244,73 +247,77 @@ func TestResultUnmarshalingFailures(t *testing.T) {
 		for _, testCase := range []struct {
 			name    string
 			err     string
-			corrupt func(*apiaudit.DataAuditResult)
+			corrupt func(*protoaudit.DataAuditResult)
 		}{
-			{name: "missing container", err: "missing container", corrupt: func(r *apiaudit.DataAuditResult) {
-				r.SetContainerID(nil)
+			{name: "missing container", err: "missing container", corrupt: func(r *protoaudit.DataAuditResult) {
+				r.ContainerId = nil
 			}},
-			{name: "invalid container/nil value", err: "invalid container: invalid length 0", corrupt: func(r *apiaudit.DataAuditResult) {
-				r.SetContainerID(new(refs.ContainerID))
+			{name: "invalid container/nil value", err: "invalid container: invalid length 0", corrupt: func(r *protoaudit.DataAuditResult) {
+				r.ContainerId = new(refs.ContainerID)
 			}},
-			{name: "invalid container/empty value", err: "invalid container: invalid length 0", corrupt: func(r *apiaudit.DataAuditResult) {
-				var id refs.ContainerID
-				id.SetValue([]byte{})
-				r.SetContainerID(&id)
+			{name: "invalid container/empty value", err: "invalid container: invalid length 0", corrupt: func(r *protoaudit.DataAuditResult) {
+				var id = refs.ContainerID{
+					Value: []byte{},
+				}
+				r.ContainerId = &id
 			}},
-			{name: "invalid container/wrong length", err: "invalid container: invalid length 31", corrupt: func(r *apiaudit.DataAuditResult) {
-				var id refs.ContainerID
-				id.SetValue(make([]byte, 31))
-				r.SetContainerID(&id)
+			{name: "invalid container/wrong length", err: "invalid container: invalid length 31", corrupt: func(r *protoaudit.DataAuditResult) {
+				var id = refs.ContainerID{
+					Value: make([]byte, 31),
+				}
+				r.ContainerId = &id
 			}},
-			{name: "invalid passed SG/nil value", err: "invalid passed storage group #1: invalid length 0", corrupt: func(r *apiaudit.DataAuditResult) {
-				ids := make([]refs.ObjectID, 3)
-				ids[0].SetValue(randomObjectID())
-				ids[2].SetValue(randomObjectID())
-				r.SetPassSG(ids)
+			{name: "invalid passed SG/nil value", err: "invalid passed storage group #1: invalid length 0", corrupt: func(r *protoaudit.DataAuditResult) {
+				ids := make([]*refs.ObjectID, 3)
+				ids[0] = &refs.ObjectID{Value: randomObjectID()}
+				ids[2] = &refs.ObjectID{Value: randomObjectID()}
+				r.PassSg = ids
 			}},
-			{name: "invalid passed SG/empty value", err: "invalid passed storage group #1: invalid length 0", corrupt: func(r *apiaudit.DataAuditResult) {
-				ids := make([]refs.ObjectID, 3)
-				ids[0].SetValue(randomObjectID())
-				ids[1].SetValue([]byte{})
-				ids[2].SetValue(randomObjectID())
-				r.SetPassSG(ids)
+			{name: "invalid passed SG/empty value", err: "invalid passed storage group #1: invalid length 0", corrupt: func(r *protoaudit.DataAuditResult) {
+				ids := make([]*refs.ObjectID, 3)
+				ids[0] = &refs.ObjectID{Value: randomObjectID()}
+				ids[1] = &refs.ObjectID{Value: []byte{}}
+				ids[2] = &refs.ObjectID{Value: randomObjectID()}
+				r.PassSg = ids
 			}},
-			{name: "invalid passed SG/wrong length", err: "invalid passed storage group #1: invalid length 31", corrupt: func(r *apiaudit.DataAuditResult) {
-				ids := make([]refs.ObjectID, 3)
-				ids[0].SetValue(randomObjectID())
-				ids[1].SetValue(make([]byte, 31))
-				ids[2].SetValue(randomObjectID())
-				r.SetPassSG(ids)
+			{name: "invalid passed SG/wrong length", err: "invalid passed storage group #1: invalid length 31", corrupt: func(r *protoaudit.DataAuditResult) {
+				ids := make([]*refs.ObjectID, 3)
+				ids[0] = &refs.ObjectID{Value: randomObjectID()}
+				ids[1] = &refs.ObjectID{Value: make([]byte, 31)}
+				ids[2] = &refs.ObjectID{Value: randomObjectID()}
+				r.PassSg = ids
 			}},
-			{name: "invalid failed SG/nil value", err: "invalid failed storage group #1: invalid length 0", corrupt: func(r *apiaudit.DataAuditResult) {
-				ids := make([]refs.ObjectID, 3)
-				ids[0].SetValue(randomObjectID())
-				ids[2].SetValue(randomObjectID())
-				r.SetFailSG(ids)
+			{name: "invalid failed SG/nil value", err: "invalid failed storage group #1: invalid length 0", corrupt: func(r *protoaudit.DataAuditResult) {
+				ids := make([]*refs.ObjectID, 3)
+				ids[0] = &refs.ObjectID{Value: randomObjectID()}
+				ids[2] = &refs.ObjectID{Value: randomObjectID()}
+				r.FailSg = ids
 			}},
-			{name: "invalid failed SG/empty value", err: "invalid failed storage group #1: invalid length 0", corrupt: func(r *apiaudit.DataAuditResult) {
-				ids := make([]refs.ObjectID, 3)
-				ids[0].SetValue(randomObjectID())
-				ids[1].SetValue([]byte{})
-				ids[2].SetValue(randomObjectID())
-				r.SetFailSG(ids)
+			{name: "invalid failed SG/empty value", err: "invalid failed storage group #1: invalid length 0", corrupt: func(r *protoaudit.DataAuditResult) {
+				ids := make([]*refs.ObjectID, 3)
+				ids[0] = &refs.ObjectID{Value: randomObjectID()}
+				ids[1] = &refs.ObjectID{Value: []byte{}}
+				ids[2] = &refs.ObjectID{Value: randomObjectID()}
+				r.FailSg = ids
 			}},
-			{name: "invalid failed SG/wrong length", err: "invalid failed storage group #1: invalid length 31", corrupt: func(r *apiaudit.DataAuditResult) {
-				ids := make([]refs.ObjectID, 3)
-				ids[0].SetValue(randomObjectID())
-				ids[1].SetValue(make([]byte, 31))
-				ids[2].SetValue(randomObjectID())
-				r.SetFailSG(ids)
+			{name: "invalid failed SG/wrong length", err: "invalid failed storage group #1: invalid length 31", corrupt: func(r *protoaudit.DataAuditResult) {
+				ids := make([]*refs.ObjectID, 3)
+				ids[0] = &refs.ObjectID{Value: randomObjectID()}
+				ids[1] = &refs.ObjectID{Value: make([]byte, 31)}
+				ids[2] = &refs.ObjectID{Value: randomObjectID()}
+				r.FailSg = ids
 			}},
 		} {
 			t.Run(testCase.name, func(t *testing.T) {
 				r := anyValidAuditResult()
-				var msg apiaudit.DataAuditResult
-				require.NoError(t, msg.Unmarshal(r.Marshal()))
+				var msg protoaudit.DataAuditResult
+				require.NoError(t, proto.Unmarshal(r.Marshal(), &msg))
 
 				testCase.corrupt(&msg)
 
-				require.EqualError(t, r.Unmarshal(msg.StableMarshal(nil)), testCase.err)
+				b := make([]byte, msg.MarshaledSize())
+				msg.MarshalStable(b)
+				require.EqualError(t, r.Unmarshal(b), testCase.err)
 			})
 		}
 	})
diff --git a/pkg/services/container/server.go b/pkg/services/container/server.go
index ec0a6c4f32..7062425669 100644
--- a/pkg/services/container/server.go
+++ b/pkg/services/container/server.go
@@ -6,23 +6,18 @@ import (
 	"errors"
 	"fmt"
 
-	apiacl "github.com/nspcc-dev/neofs-api-go/v2/acl"
-	protoacl "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
-	apicontainer "github.com/nspcc-dev/neofs-api-go/v2/container"
-	protocontainer "github.com/nspcc-dev/neofs-api-go/v2/container/grpc"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	apisession "github.com/nspcc-dev/neofs-api-go/v2/session"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/services/util"
 	apistatus "github.com/nspcc-dev/neofs-sdk-go/client/status"
 	"github.com/nspcc-dev/neofs-sdk-go/container"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
+	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
 	neofsecdsa "github.com/nspcc-dev/neofs-sdk-go/crypto/ecdsa"
 	"github.com/nspcc-dev/neofs-sdk-go/eacl"
+	protocontainer "github.com/nspcc-dev/neofs-sdk-go/proto/container"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 	"github.com/nspcc-dev/neofs-sdk-go/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
@@ -74,11 +69,8 @@ func New(s *ecdsa.PrivateKey, net netmap.State, c Contract) protocontainer.Conta
 }
 
 func (s *server) makeResponseMetaHeader(st *protostatus.Status) *protosession.ResponseMetaHeader {
-	v := version.Current()
-	var v2 apirefs.Version
-	v.WriteToV2(&v2)
 	return &protosession.ResponseMetaHeader{
-		Version: v2.ToGRPCMessage().(*refs.Version),
+		Version: version.Current().ProtoMessage(),
 		Epoch:   s.net.CurrentEpoch(),
 		Status:  st,
 	}
@@ -99,12 +91,8 @@ func (s *server) getVerifiedSessionToken(req interface {
 		return nil, nil
 	}
 
-	var st2 apisession.Token
-	if err := st2.FromGRPCMessage(m); err != nil {
-		panic(err)
-	}
 	var token session.Container
-	if err := token.ReadFromV2(st2); err != nil {
+	if err := token.FromProtoMessage(m); err != nil {
 		return nil, fmt.Errorf("decode: %w", err)
 	}
 
@@ -150,17 +138,27 @@ func (s *server) checkSessionIssuer(id cid.ID, token session.Container) error {
 		return fmt.Errorf("get container by ID: %w", err)
 	}
 
-	var token2 apisession.Token // TODO: get signature directly from token on SDK upgrade
-	token.WriteToV2(&token2)
-	mSig := token2.GetSignature()
+	mSig, ok := token.Signature()
+	if !ok {
+		return errors.New("missing token signature")
+	}
+
+	// No more elegant way to match these for now
+	var pub ecdsa.PublicKey
 
-	var pub neofsecdsa.PublicKey
-	if err := pub.Decode(mSig.GetKey()); err != nil {
-		return fmt.Errorf("invalid public key in the session token signature: %w", err)
+	switch v := mSig.PublicKey().(type) {
+	case *neofsecdsa.PublicKey:
+		pub = ecdsa.PublicKey(*v)
+	case *neofsecdsa.PublicKeyRFC6979:
+		pub = ecdsa.PublicKey(*v)
+	case *neofsecdsa.PublicKeyWalletConnect:
+		pub = ecdsa.PublicKey(*v)
+	default:
+		return fmt.Errorf("unexpected public key type %T in the session token signature", v)
 	}
 
 	issuer := token.Issuer()
-	if signer := user.NewFromECDSAPublicKey(ecdsa.PublicKey(pub)); signer != issuer {
+	if signer := user.NewFromECDSAPublicKey(pub); signer != issuer {
 		return errors.New("session token is signed not by its issuer")
 	}
 
@@ -176,7 +174,8 @@ func (s *server) makePutResponse(body *protocontainer.PutResponse_Body, st *prot
 		Body:       body,
 		MetaHeader: s.makeResponseMetaHeader(st),
 	}
-	return util.SignResponse(s.signer, resp, apicontainer.PutResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeFailedPutResponse(err error) (*protocontainer.PutResponse, error) {
@@ -187,11 +186,7 @@ func (s *server) makeFailedPutResponse(err error) (*protocontainer.PutResponse,
 // further processing. If session token is attached, it's verified. Returns ID
 // to check request status in the response.
 func (s *server) Put(_ context.Context, req *protocontainer.PutRequest) (*protocontainer.PutResponse, error) {
-	putReq := new(apicontainer.PutRequest)
-	if err := putReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(putReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeFailedPutResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -206,11 +201,7 @@ func (s *server) Put(_ context.Context, req *protocontainer.PutRequest) (*protoc
 	}
 
 	var cnr container.Container
-	var cnr2 apicontainer.Container
-	if err := cnr2.FromGRPCMessage(mCnr); err != nil {
-		panic(err)
-	}
-	if err := cnr.ReadFromV2(cnr2); err != nil {
+	if err := cnr.FromProtoMessage(mCnr); err != nil {
 		return s.makeFailedPutResponse(fmt.Errorf("invalid container: %w", err))
 	}
 
@@ -224,10 +215,8 @@ func (s *server) Put(_ context.Context, req *protocontainer.PutRequest) (*protoc
 		return s.makeFailedPutResponse(err)
 	}
 
-	var id2 apirefs.ContainerID
-	id.WriteToV2(&id2)
 	respBody := &protocontainer.PutResponse_Body{
-		ContainerId: id2.ToGRPCMessage().(*refs.ContainerID),
+		ContainerId: id.ProtoMessage(),
 	}
 	return s.makePutResponse(respBody, util.StatusOK)
 }
@@ -236,17 +225,14 @@ func (s *server) makeDeleteResponse(err error) (*protocontainer.DeleteResponse,
 	resp := &protocontainer.DeleteResponse{
 		MetaHeader: s.makeResponseMetaHeader(util.ToStatus(err)),
 	}
-	return util.SignResponse(s.signer, resp, apicontainer.DeleteResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 // Delete forwards container removal request to the underlying [Contract] for
 // further processing. If session token is attached, it's verified.
 func (s *server) Delete(_ context.Context, req *protocontainer.DeleteRequest) (*protocontainer.DeleteResponse, error) {
-	delReq := new(apicontainer.DeleteRequest)
-	if err := delReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(delReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeDeleteResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -260,12 +246,8 @@ func (s *server) Delete(_ context.Context, req *protocontainer.DeleteRequest) (*
 		return s.makeDeleteResponse(errors.New("missing ID"))
 	}
 
-	var id2 apirefs.ContainerID
-	if err := id2.FromGRPCMessage(mID); err != nil {
-		panic(err)
-	}
 	var id cid.ID
-	if err := id.ReadFromV2(id2); err != nil {
+	if err := id.FromProtoMessage(mID); err != nil {
 		return s.makeDeleteResponse(fmt.Errorf("invalid ID: %w", err))
 	}
 
@@ -294,7 +276,8 @@ func (s *server) makeGetResponse(body *protocontainer.GetResponse_Body, st *prot
 		Body:       body,
 		MetaHeader: s.makeResponseMetaHeader(st),
 	}
-	return util.SignResponse(s.signer, resp, apicontainer.GetResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeFailedGetResponse(err error) (*protocontainer.GetResponse, error) {
@@ -304,11 +287,7 @@ func (s *server) makeFailedGetResponse(err error) (*protocontainer.GetResponse,
 // Get requests container from the underlying [Contract] and returns it in the
 // response.
 func (s *server) Get(_ context.Context, req *protocontainer.GetRequest) (*protocontainer.GetResponse, error) {
-	getReq := new(apicontainer.GetRequest)
-	if err := getReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(getReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeFailedGetResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -317,12 +296,8 @@ func (s *server) Get(_ context.Context, req *protocontainer.GetRequest) (*protoc
 		return s.makeFailedGetResponse(errors.New("missing ID"))
 	}
 
-	var id2 apirefs.ContainerID
-	if err := id2.FromGRPCMessage(mID); err != nil {
-		panic(err)
-	}
 	var id cid.ID
-	if err := id.ReadFromV2(id2); err != nil {
+	if err := id.FromProtoMessage(mID); err != nil {
 		return s.makeFailedGetResponse(fmt.Errorf("invalid ID: %w", err))
 	}
 
@@ -331,10 +306,8 @@ func (s *server) Get(_ context.Context, req *protocontainer.GetRequest) (*protoc
 		return s.makeFailedGetResponse(err)
 	}
 
-	var cnr2 apicontainer.Container
-	cnr.WriteToV2(&cnr2)
 	body := &protocontainer.GetResponse_Body{
-		Container: cnr2.ToGRPCMessage().(*protocontainer.Container),
+		Container: cnr.ProtoMessage(),
 	}
 	return s.makeGetResponse(body, nil)
 }
@@ -344,7 +317,8 @@ func (s *server) makeListResponse(body *protocontainer.ListResponse_Body, st *pr
 		Body:       body,
 		MetaHeader: s.makeResponseMetaHeader(st),
 	}
-	return util.SignResponse(s.signer, resp, apicontainer.ListResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeFailedListResponse(err error) (*protocontainer.ListResponse, error) {
@@ -354,11 +328,7 @@ func (s *server) makeFailedListResponse(err error) (*protocontainer.ListResponse
 // List lists user containers from the underlying [Contract] and returns their
 // IDs in the response.
 func (s *server) List(_ context.Context, req *protocontainer.ListRequest) (*protocontainer.ListResponse, error) {
-	listReq := new(apicontainer.ListRequest)
-	if err := listReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(listReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeFailedListResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -367,12 +337,8 @@ func (s *server) List(_ context.Context, req *protocontainer.ListRequest) (*prot
 		return s.makeFailedListResponse(errors.New("missing user"))
 	}
 
-	var id2 apirefs.OwnerID
-	if err := id2.FromGRPCMessage(mID); err != nil {
-		panic(err)
-	}
 	var id user.ID
-	if err := id.ReadFromV2(id2); err != nil {
+	if err := id.FromProtoMessage(mID); err != nil {
 		return s.makeFailedListResponse(fmt.Errorf("invalid user: %w", err))
 	}
 
@@ -385,15 +351,11 @@ func (s *server) List(_ context.Context, req *protocontainer.ListRequest) (*prot
 		return s.makeListResponse(nil, util.StatusOK)
 	}
 
-	cs2 := make([]apirefs.ContainerID, len(cs))
-	for i := range cs {
-		cs[i].WriteToV2(&cs2[i])
-	}
 	body := &protocontainer.ListResponse_Body{
 		ContainerIds: make([]*refs.ContainerID, len(cs)),
 	}
 	for i := range cs {
-		body.ContainerIds[i] = cs2[i].ToGRPCMessage().(*refs.ContainerID)
+		body.ContainerIds[i] = cs[i].ProtoMessage()
 	}
 	return s.makeListResponse(body, util.StatusOK)
 }
@@ -402,17 +364,14 @@ func (s *server) makeSetEACLResponse(err error) (*protocontainer.SetExtendedACLR
 	resp := &protocontainer.SetExtendedACLResponse{
 		MetaHeader: s.makeResponseMetaHeader(util.ToStatus(err)),
 	}
-	return util.SignResponse(s.signer, resp, apicontainer.SetExtendedACLResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 // SetExtendedACL forwards eACL setting request to the underlying [Contract]
 // for further processing. If session token is attached, it's verified.
 func (s *server) SetExtendedACL(_ context.Context, req *protocontainer.SetExtendedACLRequest) (*protocontainer.SetExtendedACLResponse, error) {
-	setEACLReq := new(apicontainer.SetExtendedACLRequest)
-	if err := setEACLReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(setEACLReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeSetEACLResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -426,12 +385,8 @@ func (s *server) SetExtendedACL(_ context.Context, req *protocontainer.SetExtend
 		return s.makeSetEACLResponse(errors.New("missing eACL"))
 	}
 
-	var eACL2 apiacl.Table
-	if err := eACL2.FromGRPCMessage(mEACL); err != nil {
-		panic(err)
-	}
 	var eACL eacl.Table
-	if err := eACL.ReadFromV2(eACL2); err != nil {
+	if err := eACL.FromProtoMessage(mEACL); err != nil {
 		return s.makeSetEACLResponse(fmt.Errorf("invalid eACL: %w", err))
 	}
 
@@ -461,7 +416,8 @@ func (s *server) makeGetEACLResponse(body *protocontainer.GetExtendedACLResponse
 		Body:       body,
 		MetaHeader: s.makeResponseMetaHeader(st),
 	}
-	return util.SignResponse(s.signer, resp, apicontainer.GetExtendedACLResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeFailedGetEACLResponse(err error) (*protocontainer.GetExtendedACLResponse, error) {
@@ -471,11 +427,7 @@ func (s *server) makeFailedGetEACLResponse(err error) (*protocontainer.GetExtend
 // GetExtendedACL read eACL of the requested container from the underlying
 // [Contract] and returns the result in the response.
 func (s *server) GetExtendedACL(_ context.Context, req *protocontainer.GetExtendedACLRequest) (*protocontainer.GetExtendedACLResponse, error) {
-	getEACLReq := new(apicontainer.GetExtendedACLRequest)
-	if err := getEACLReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(getEACLReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeFailedGetEACLResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -484,12 +436,8 @@ func (s *server) GetExtendedACL(_ context.Context, req *protocontainer.GetExtend
 		return s.makeFailedGetEACLResponse(errors.New("missing ID"))
 	}
 
-	var id2 apirefs.ContainerID
-	if err := id2.FromGRPCMessage(mID); err != nil {
-		panic(err)
-	}
 	var id cid.ID
-	if err := id.ReadFromV2(id2); err != nil {
+	if err := id.FromProtoMessage(mID); err != nil {
 		return s.makeFailedGetEACLResponse(fmt.Errorf("invalid ID: %w", err))
 	}
 
@@ -499,7 +447,7 @@ func (s *server) GetExtendedACL(_ context.Context, req *protocontainer.GetExtend
 	}
 
 	body := &protocontainer.GetExtendedACLResponse_Body{
-		Eacl: eACL.ToV2().ToGRPCMessage().(*protoacl.EACLTable),
+		Eacl: eACL.ProtoMessage(),
 	}
 	return s.makeGetEACLResponse(body, util.StatusOK)
 }
diff --git a/pkg/services/container/server_test.go b/pkg/services/container/server_test.go
index 75923cc5b6..dea542c8fa 100644
--- a/pkg/services/container/server_test.go
+++ b/pkg/services/container/server_test.go
@@ -6,19 +6,17 @@ import (
 	"testing"
 
 	"github.com/google/uuid"
-	apicontainer "github.com/nspcc-dev/neofs-api-go/v2/container"
-	protocontainer "github.com/nspcc-dev/neofs-api-go/v2/container/grpc"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	apisession "github.com/nspcc-dev/neofs-api-go/v2/session"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
 	containerSvc "github.com/nspcc-dev/neofs-node/pkg/services/container"
 	"github.com/nspcc-dev/neofs-sdk-go/container"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
+	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
+	neofsecdsa "github.com/nspcc-dev/neofs-sdk-go/crypto/ecdsa"
 	neofscryptotest "github.com/nspcc-dev/neofs-sdk-go/crypto/test"
 	"github.com/nspcc-dev/neofs-sdk-go/eacl"
+	protocontainer "github.com/nspcc-dev/neofs-sdk-go/proto/container"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	"github.com/nspcc-dev/neofs-sdk-go/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	usertest "github.com/nspcc-dev/neofs-sdk-go/user/test"
@@ -57,20 +55,17 @@ func (testFSChain) Delete(cid.ID, []byte, []byte, *session.Container) error {
 }
 
 func makeDeleteRequestWithSession(t testing.TB, usr usertest.UserSigner, cnr cid.ID, st interface {
-	WriteToV2(token *apisession.Token)
+	ProtoMessage() *protosession.SessionToken
 }) *protocontainer.DeleteRequest {
-	var st2 apisession.Token
-	st.WriteToV2(&st2)
-	return makeDeleteRequestWithSessionMessage(t, usr, cnr, st2.ToGRPCMessage().(*protosession.SessionToken))
+	return makeDeleteRequestWithSessionMessage(t, usr, cnr, st.ProtoMessage())
 }
 
 func makeDeleteRequestWithSessionMessage(t testing.TB, usr usertest.UserSigner, cnr cid.ID, st *protosession.SessionToken) *protocontainer.DeleteRequest {
-	var cnr2 apirefs.ContainerID
-	cnr.WriteToV2(&cnr2)
+	var err error
 
 	req := &protocontainer.DeleteRequest{
 		Body: &protocontainer.DeleteRequest_Body{
-			ContainerId: cnr2.ToGRPCMessage().(*refs.ContainerID),
+			ContainerId: cnr.ProtoMessage(),
 			Signature:   new(refs.SignatureRFC6979),
 		},
 		MetaHeader: &protosession.RequestMetaHeader{
@@ -78,11 +73,10 @@ func makeDeleteRequestWithSessionMessage(t testing.TB, usr usertest.UserSigner,
 		},
 	}
 
-	var req2 apicontainer.DeleteRequest
-	require.NoError(t, req2.FromGRPCMessage(req))
-	require.NoError(t, signature.SignServiceMessage(&usr.ECDSAPrivateKey, &req2))
+	req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer(neofsecdsa.Signer(usr.ECDSAPrivateKey), req, nil)
+	require.NoError(t, err)
 
-	return req2.ToGRPCMessage().(*protocontainer.DeleteRequest)
+	return req
 }
 
 func TestServer_Delete(t *testing.T) {
@@ -121,7 +115,7 @@ func TestServer_Delete(t *testing.T) {
 				require.NotNil(t, resp.MetaHeader.Status)
 				sts := resp.MetaHeader.Status
 				require.EqualValues(t, 1024, sts.Code, st)
-				require.Equal(t, "invalid context *session.ObjectSessionContext", sts.Message)
+				require.Equal(t, "invalid context *session.SessionToken_Body_Object", sts.Message)
 				require.Zero(t, sts.Details)
 			})
 			t.Run("wrong verb", func(t *testing.T) {
@@ -213,9 +207,7 @@ func TestServer_Delete(t *testing.T) {
 				st.ForVerb(session.VerbContainerDelete)
 				require.NoError(t, st.Sign(usr))
 
-				var st2 apisession.Token
-				st.WriteToV2(&st2)
-				mst := st2.ToGRPCMessage().(*protosession.SessionToken)
+				mst := st.ProtoMessage()
 				require.NotEmpty(t, mst.Signature.Sign)
 				mst.Signature.Sign[0]++
 
diff --git a/pkg/services/netmap/server.go b/pkg/services/netmap/server.go
index de5b070d23..efd8cf7217 100644
--- a/pkg/services/netmap/server.go
+++ b/pkg/services/netmap/server.go
@@ -4,16 +4,14 @@ import (
 	"context"
 	"crypto/ecdsa"
 
-	apinetmap "github.com/nspcc-dev/neofs-api-go/v2/netmap"
-	protonetmap "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/services/util"
+	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
+	protonetmap "github.com/nspcc-dev/neofs-sdk-go/proto/netmap"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
 )
 
@@ -48,10 +46,7 @@ func New(s *ecdsa.PrivateKey, c Contract) protonetmap.NetmapServiceServer {
 }
 
 func currentProtoVersion() *refs.Version {
-	v := version.Current()
-	var v2 apirefs.Version
-	v.WriteToV2(&v2)
-	return v2.ToGRPCMessage().(*refs.Version)
+	return version.Current().ProtoMessage()
 }
 
 func (s *server) makeResponseMetaHeader(st *protostatus.Status) *protosession.ResponseMetaHeader {
@@ -67,7 +62,8 @@ func (s *server) makeNodeInfoResponse(body *protonetmap.LocalNodeInfoResponse_Bo
 		Body:       body,
 		MetaHeader: s.makeResponseMetaHeader(st),
 	}
-	return util.SignResponse(s.signer, resp, apinetmap.LocalNodeInfoResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeStatusNodeInfoResponse(err error) (*protonetmap.LocalNodeInfoResponse, error) {
@@ -77,11 +73,7 @@ func (s *server) makeStatusNodeInfoResponse(err error) (*protonetmap.LocalNodeIn
 // LocalNodeInfo returns current state of the local node from the underlying
 // [NodeState].
 func (s server) LocalNodeInfo(_ context.Context, req *protonetmap.LocalNodeInfoRequest) (*protonetmap.LocalNodeInfoResponse, error) {
-	nodeInfoReq := new(apinetmap.LocalNodeInfoRequest)
-	if err := nodeInfoReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(nodeInfoReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeStatusNodeInfoResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -90,11 +82,9 @@ func (s server) LocalNodeInfo(_ context.Context, req *protonetmap.LocalNodeInfoR
 		return s.makeStatusNodeInfoResponse(err)
 	}
 
-	var n2 apinetmap.NodeInfo
-	n.WriteToV2(&n2)
 	body := &protonetmap.LocalNodeInfoResponse_Body{
 		Version:  currentProtoVersion(),
-		NodeInfo: n2.ToGRPCMessage().(*protonetmap.NodeInfo),
+		NodeInfo: n.ProtoMessage(),
 	}
 	return s.makeNodeInfoResponse(body, util.StatusOK)
 }
@@ -104,7 +94,8 @@ func (s *server) makeNetInfoResponse(body *protonetmap.NetworkInfoResponse_Body,
 		Body:       body,
 		MetaHeader: s.makeResponseMetaHeader(st),
 	}
-	return util.SignResponse(s.signer, resp, apinetmap.NetworkInfoResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeStatusNetInfoResponse(err error) (*protonetmap.NetworkInfoResponse, error) {
@@ -114,11 +105,7 @@ func (s *server) makeStatusNetInfoResponse(err error) (*protonetmap.NetworkInfoR
 // NetworkInfo returns current network configuration from the underlying
 // [Contract].
 func (s *server) NetworkInfo(_ context.Context, req *protonetmap.NetworkInfoRequest) (*protonetmap.NetworkInfoResponse, error) {
-	netInfoReq := new(apinetmap.NetworkInfoRequest)
-	if err := netInfoReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(netInfoReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeStatusNetInfoResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -127,10 +114,8 @@ func (s *server) NetworkInfo(_ context.Context, req *protonetmap.NetworkInfoRequ
 		return s.makeStatusNetInfoResponse(err)
 	}
 
-	var n2 apinetmap.NetworkInfo
-	n.WriteToV2(&n2)
 	body := &protonetmap.NetworkInfoResponse_Body{
-		NetworkInfo: n2.ToGRPCMessage().(*protonetmap.NetworkInfo),
+		NetworkInfo: n.ProtoMessage(),
 	}
 	return s.makeNetInfoResponse(body, util.StatusOK)
 }
@@ -140,7 +125,8 @@ func (s *server) makeNetmapResponse(body *protonetmap.NetmapSnapshotResponse_Bod
 		Body:       body,
 		MetaHeader: s.makeResponseMetaHeader(st),
 	}
-	return util.SignResponse(s.signer, resp, apinetmap.SnapshotResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeStatusNetmapResponse(err error) (*protonetmap.NetmapSnapshotResponse, error) {
@@ -149,11 +135,7 @@ func (s *server) makeStatusNetmapResponse(err error) (*protonetmap.NetmapSnapsho
 
 // NetmapSnapshot returns current network map from the underlying [Contract].
 func (s *server) NetmapSnapshot(_ context.Context, req *protonetmap.NetmapSnapshotRequest) (*protonetmap.NetmapSnapshotResponse, error) {
-	snapshotReq := new(apinetmap.SnapshotRequest)
-	if err := snapshotReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(snapshotReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeStatusNetmapResponse(util.ToRequestSignatureVerificationError(err))
 	}
 
@@ -162,10 +144,8 @@ func (s *server) NetmapSnapshot(_ context.Context, req *protonetmap.NetmapSnapsh
 		return s.makeStatusNetmapResponse(err)
 	}
 
-	var n2 apinetmap.NetMap
-	n.WriteToV2(&n2)
 	body := &protonetmap.NetmapSnapshotResponse_Body{
-		Netmap: n2.ToGRPCMessage().(*protonetmap.Netmap),
+		Netmap: n.ProtoMessage(),
 	}
 	return s.makeNetmapResponse(body, util.StatusOK)
 }
diff --git a/pkg/services/object/acl/eacl/v2/eacl_test.go b/pkg/services/object/acl/eacl/v2/eacl_test.go
index 81aa882ef9..8f6af93c25 100644
--- a/pkg/services/object/acl/eacl/v2/eacl_test.go
+++ b/pkg/services/object/acl/eacl/v2/eacl_test.go
@@ -6,10 +6,6 @@ import (
 	"testing"
 
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	protoobject "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
 	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
 	eaclSDK "github.com/nspcc-dev/neofs-sdk-go/eacl"
@@ -17,6 +13,9 @@ import (
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
 	objecttest "github.com/nspcc-dev/neofs-sdk-go/object/test"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/stretchr/testify/require"
 )
@@ -48,11 +47,7 @@ func (s *testLocalStorage) Head(addr oid.Address) (*object.Object, error) {
 
 func TestHeadRequest(t *testing.T) {
 	cnr := cidtest.ID()
-	var cnr2 apirefs.ContainerID
-	cnr.WriteToV2(&cnr2)
 	id := oidtest.ID()
-	var id2 apirefs.ObjectID
-	id.WriteToV2(&id2)
 
 	xKey := "x-key"
 	xVal := "x-val"
@@ -61,8 +56,8 @@ func TestHeadRequest(t *testing.T) {
 	req := &protoobject.HeadRequest{
 		Body: &protoobject.HeadRequest_Body{
 			Address: &refs.Address{
-				ContainerId: cnr2.ToGRPCMessage().(*refs.ContainerID),
-				ObjectId:    id2.ToGRPCMessage().(*refs.ObjectID),
+				ContainerId: cnr.ProtoMessage(),
+				ObjectId:    id.ProtoMessage(),
 			},
 		},
 		MetaHeader: &protosession.RequestMetaHeader{
@@ -179,13 +174,9 @@ func TestV2Split(t *testing.T) {
 	firstObject.SetParent(&originalObject)
 	require.NoError(t, firstObject.CalculateAndSetID())
 
-	var firstIDV2 apirefs.ObjectID
-	firstID := firstObject.GetID()
-	firstID.WriteToV2(&firstIDV2)
-
 	hs := &protoobject.Header_Split{
-		ParentHeader: originalObject.ToV2().GetHeader().ToGRPCMessage().(*protoobject.Header),
-		First:        firstIDV2.ToGRPCMessage().(*refs.ObjectID),
+		ParentHeader: originalObject.ProtoMessage().Header,
+		First:        firstObject.GetID().ProtoMessage(),
 	}
 	hdr := &protoobject.Header{
 		Split: hs,
@@ -251,7 +242,7 @@ func TestV2Split(t *testing.T) {
 		originalObjectNoRestrictedAttr.SetID(oid.ID{}) // no object ID for an original object in the first object
 		originalObjectNoRestrictedAttr.SetSignature(&neofscrypto.Signature{})
 
-		hs.ParentHeader = originalObjectNoRestrictedAttr.ToV2().GetHeader().ToGRPCMessage().(*protoobject.Header)
+		hs.ParentHeader = originalObjectNoRestrictedAttr.ProtoMessage().Header
 
 		// allow an object whose first obj does not have the restricted attribute
 		checkDefaultAction(t, validator, unit.WithHeaderSource(newSource(t)))
diff --git a/pkg/services/object/acl/eacl/v2/headers.go b/pkg/services/object/acl/eacl/v2/headers.go
index d8a563baee..8ea69f59b0 100644
--- a/pkg/services/object/acl/eacl/v2/headers.go
+++ b/pkg/services/object/acl/eacl/v2/headers.go
@@ -4,15 +4,12 @@ import (
 	"errors"
 	"fmt"
 
-	objectV2 "github.com/nspcc-dev/neofs-api-go/v2/object"
-	protoobject "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	refsV2 "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	session "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	eaclSDK "github.com/nspcc-dev/neofs-sdk-go/eacl"
 	"github.com/nspcc-dev/neofs-sdk-go/object"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 )
 
@@ -149,12 +146,13 @@ func (h *cfg) readObjectHeaders(dst *headerSource) error {
 						ObjectId: in.ObjectId,
 						Header:   in.Header,
 					}
-					oV2 := new(objectV2.Object)
-					if err := oV2.FromGRPCMessage(mo); err != nil {
-						panic(err)
-					}
 
-					dst.objectHeaders = headersFromObject(object.NewFromV2(oV2), h.cnr, h.obj)
+					var obj object.Object
+					err := obj.FromProtoMessage(mo)
+					if err != nil {
+						return err
+					}
+					dst.objectHeaders = headersFromObject(&obj, h.cnr, h.obj)
 
 					break
 				}
@@ -168,22 +166,20 @@ func (h *cfg) readObjectHeaders(dst *headerSource) error {
 						Signature: splitHeader.ParentSignature,
 						Header:    parentHeader,
 					}
-					var parentObjectV2 objectV2.Object
-					if err := parentObjectV2.FromGRPCMessage(mo); err != nil {
-						panic(err)
-					}
 
-					dst.objectHeaders = headersFromObject(object.NewFromV2(&parentObjectV2), h.cnr, h.obj)
+					var obj object.Object
+					err := obj.FromProtoMessage(mo)
+					if err != nil {
+						return err
+					}
+					dst.objectHeaders = headersFromObject(&obj, h.cnr, h.obj)
 				} else {
 					// middle object, parent header should
 					// be received via the first object
 					if mf := in.Header.GetSplit().GetFirst(); mf != nil {
 						var firstID oid.ID
-						var first refsV2.ObjectID
-						if err := first.FromGRPCMessage(mf); err != nil {
-							panic(err)
-						}
-						err := firstID.ReadFromV2(first)
+
+						err := firstID.FromProtoMessage(mf)
 						if err != nil {
 							return fmt.Errorf("converting first object ID: %w", err)
 						}
@@ -207,11 +203,7 @@ func (h *cfg) readObjectHeaders(dst *headerSource) error {
 			var cnr cid.ID
 
 			if mc := req.GetBody().GetContainerId(); mc != nil {
-				var cnrV2 refsV2.ContainerID
-				if err := cnrV2.FromGRPCMessage(mc); err != nil {
-					panic(err)
-				}
-				if err := cnr.ReadFromV2(cnrV2); err != nil {
+				if err := cnr.FromProtoMessage(mc); err != nil {
 					return fmt.Errorf("can't parse container ID: %w", err)
 				}
 			}
@@ -234,12 +226,13 @@ func (h *cfg) readObjectHeaders(dst *headerSource) error {
 					ObjectId: v.Init.ObjectId,
 					Header:   v.Init.Header,
 				}
-				oV2 := new(objectV2.Object)
-				if err := oV2.FromGRPCMessage(mo); err != nil {
-					panic(err)
-				}
 
-				dst.objectHeaders = headersFromObject(object.NewFromV2(oV2), h.cnr, h.obj)
+				var obj object.Object
+				err := obj.FromProtoMessage(mo)
+				if err != nil {
+					return err
+				}
+				dst.objectHeaders = headersFromObject(&obj, h.cnr, h.obj)
 			}
 		case *protoobject.HeadResponse:
 			var hdr *protoobject.Header
@@ -250,13 +243,12 @@ func (h *cfg) readObjectHeaders(dst *headerSource) error {
 					return errors.New("nil oneof field with short header")
 				}
 
-				var idV2 refsV2.ContainerID
-				h.cnr.WriteToV2(&idV2)
+				idMsg := h.cnr.ProtoMessage()
 
 				h := v.ShortHeader
 				hdr = &protoobject.Header{
 					Version:       h.Version,
-					ContainerId:   idV2.ToGRPCMessage().(*refs.ContainerID),
+					ContainerId:   idMsg,
 					OwnerId:       h.OwnerId,
 					CreationEpoch: h.CreationEpoch,
 					PayloadLength: h.PayloadLength,
@@ -272,12 +264,13 @@ func (h *cfg) readObjectHeaders(dst *headerSource) error {
 			mo := &protoobject.Object{
 				Header: hdr,
 			}
-			oV2 := new(objectV2.Object)
-			if err := oV2.FromGRPCMessage(mo); err != nil {
-				panic(err)
-			}
 
-			dst.objectHeaders = headersFromObject(object.NewFromV2(oV2), h.cnr, h.obj)
+			var obj object.Object
+			err := obj.FromProtoMessage(mo)
+			if err != nil {
+				return err
+			}
+			dst.objectHeaders = headersFromObject(&obj, h.cnr, h.obj)
 		}
 	}
 
diff --git a/pkg/services/object/acl/eacl/v2/object.go b/pkg/services/object/acl/eacl/v2/object.go
index d7017e8be0..771bdf83b4 100644
--- a/pkg/services/object/acl/eacl/v2/object.go
+++ b/pkg/services/object/acl/eacl/v2/object.go
@@ -7,6 +7,7 @@ import (
 	eaclSDK "github.com/nspcc-dev/neofs-sdk-go/eacl"
 	"github.com/nspcc-dev/neofs-sdk-go/object"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	"github.com/nspcc-dev/neofs-sdk-go/version"
 )
 
 type sysObjHdr struct {
@@ -33,6 +34,10 @@ func headersFromObject(obj *object.Object, cnr cid.ID, oid *oid.ID) []eaclSDK.He
 
 	res := make([]eaclSDK.Header, 0, count)
 	for ; obj != nil; obj = obj.Parent() {
+		var ver = obj.Version()
+		if ver == nil {
+			ver = &version.Version{}
+		}
 		res = append(res,
 			cidHeader(cnr),
 			// creation epoch
@@ -48,7 +53,7 @@ func headersFromObject(obj *object.Object, cnr cid.ID, oid *oid.ID) []eaclSDK.He
 			// object version
 			sysObjHdr{
 				k: eaclSDK.FilterObjectVersion,
-				v: obj.Version().String(),
+				v: ver.String(),
 			},
 			// object type
 			sysObjHdr{
diff --git a/pkg/services/object/acl/eacl/v2/xheader.go b/pkg/services/object/acl/eacl/v2/xheader.go
index dad68076db..02ee145fe0 100644
--- a/pkg/services/object/acl/eacl/v2/xheader.go
+++ b/pkg/services/object/acl/eacl/v2/xheader.go
@@ -1,8 +1,8 @@
 package v2
 
 import (
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	eaclSDK "github.com/nspcc-dev/neofs-sdk-go/eacl"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 )
 
 type xHeaderSource interface {
diff --git a/pkg/services/object/acl/v2/request.go b/pkg/services/object/acl/v2/request.go
index 0f9ae5b9f9..7181e63e88 100644
--- a/pkg/services/object/acl/v2/request.go
+++ b/pkg/services/object/acl/v2/request.go
@@ -6,11 +6,11 @@ import (
 	"fmt"
 
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	"github.com/nspcc-dev/neofs-sdk-go/bearer"
 	"github.com/nspcc-dev/neofs-sdk-go/container/acl"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	sessionSDK "github.com/nspcc-dev/neofs-sdk-go/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 )
diff --git a/pkg/services/object/acl/v2/service.go b/pkg/services/object/acl/v2/service.go
index 23351c1b20..f2420ba979 100644
--- a/pkg/services/object/acl/v2/service.go
+++ b/pkg/services/object/acl/v2/service.go
@@ -4,9 +4,6 @@ import (
 	"errors"
 	"fmt"
 
-	objectV2 "github.com/nspcc-dev/neofs-api-go/v2/object"
-	protoobject "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
 	"github.com/nspcc-dev/neofs-node/pkg/core/container"
 	"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	apistatus "github.com/nspcc-dev/neofs-sdk-go/client/status"
@@ -14,6 +11,7 @@ import (
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	objectsdk "github.com/nspcc-dev/neofs-sdk-go/object"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
 	sessionSDK "github.com/nspcc-dev/neofs-sdk-go/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"go.uber.org/zap"
@@ -408,11 +406,7 @@ func (b Service) PutRequestToInfo(request *protoobject.PutRequest) (RequestInfo,
 	}
 
 	var idOwner user.ID
-	var idV2 apirefs.OwnerID
-	if err := idV2.FromGRPCMessage(mOwner); err != nil {
-		panic(err)
-	}
-	err = idOwner.ReadFromV2(idV2)
+	err = idOwner.FromProtoMessage(mOwner)
 	if err != nil {
 		return RequestInfo{}, user.ID{}, fmt.Errorf("invalid object owner: %w", err)
 	}
@@ -421,11 +415,7 @@ func (b Service) PutRequestToInfo(request *protoobject.PutRequest) (RequestInfo,
 
 	if part.Init.ObjectId != nil {
 		obj = new(oid.ID)
-		var objV2 apirefs.ObjectID
-		if err := objV2.FromGRPCMessage(part.Init.ObjectId); err != nil {
-			panic(err)
-		}
-		err = obj.ReadFromV2(objV2)
+		err = obj.FromProtoMessage(part.Init.ObjectId)
 		if err != nil {
 			return RequestInfo{}, user.ID{}, err
 		}
@@ -490,11 +480,7 @@ func (b Service) PutRequestToInfo(request *protoobject.PutRequest) (RequestInfo,
 		// header length is unchecked for replication because introducing a restriction
 		// should not prevent the replication of objects created before.
 		// See also https://github.com/nspcc-dev/neofs-api/issues/293
-		var h2 objectV2.Header
-		if err := h2.FromGRPCMessage(header); err != nil {
-			panic(err)
-		}
-		hdrLen := h2.StableSize()
+		var hdrLen = header.MarshaledSize()
 		if hdrLen > objectsdk.MaxHeaderLen {
 			return RequestInfo{}, user.ID{}, fmt.Errorf("object header length exceeds the limit: %d>%d", hdrLen, objectsdk.MaxHeaderLen)
 		}
diff --git a/pkg/services/object/acl/v2/util.go b/pkg/services/object/acl/v2/util.go
index 9c82f17f60..215c724b04 100644
--- a/pkg/services/object/acl/v2/util.go
+++ b/pkg/services/object/acl/v2/util.go
@@ -7,16 +7,13 @@ import (
 	"fmt"
 
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	apiacl "github.com/nspcc-dev/neofs-api-go/v2/acl"
-	protoobject "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	refsV2 "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	sessionV2 "github.com/nspcc-dev/neofs-api-go/v2/session"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	"github.com/nspcc-dev/neofs-sdk-go/bearer"
 	"github.com/nspcc-dev/neofs-sdk-go/container/acl"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	sessionSDK "github.com/nspcc-dev/neofs-sdk-go/session"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 )
@@ -57,11 +54,7 @@ func getContainerIDFromRequest(req any) (cid.ID, error) {
 		return cid.ID{}, errMissingContainerID
 	}
 
-	var idV2 refsV2.ContainerID
-	if err := idV2.FromGRPCMessage(mID); err != nil {
-		panic(err)
-	}
-	return id, id.ReadFromV2(idV2)
+	return id, id.FromProtoMessage(mID)
 }
 
 // originalBearerToken goes down to original request meta header and fetches
@@ -77,11 +70,7 @@ func originalBearerToken(header *protosession.RequestMetaHeader) (*bearer.Token,
 	}
 
 	var tok bearer.Token
-	var tokV2 apiacl.BearerToken
-	if err := tokV2.FromGRPCMessage(mt); err != nil {
-		panic(err)
-	}
-	return &tok, tok.ReadFromV2(tokV2)
+	return &tok, tok.FromProtoMessage(mt)
 }
 
 // originalSessionToken goes down to original request meta header and fetches
@@ -97,11 +86,7 @@ func originalSessionToken(header *protosession.RequestMetaHeader) (*sessionSDK.O
 	}
 
 	var tok sessionSDK.Object
-	var tokV2 sessionV2.Token
-	if err := tokV2.FromGRPCMessage(mt); err != nil {
-		panic(err)
-	}
-	err := tok.ReadFromV2(tokV2)
+	err := tok.FromProtoMessage(mt)
 	if err != nil {
 		return nil, fmt.Errorf("invalid session token: %w", err)
 	}
@@ -118,11 +103,7 @@ func getObjectIDFromRequestBody(body interface{ GetAddress() *refs.Address }) (*
 	}
 
 	var id oid.ID
-	var idV2 refsV2.ObjectID
-	if err := idV2.FromGRPCMessage(mID); err != nil {
-		panic(err)
-	}
-	err := id.ReadFromV2(idV2)
+	err := id.FromProtoMessage(mID)
 	if err != nil {
 		return nil, err
 	}
diff --git a/pkg/services/object/acl/v2/util_test.go b/pkg/services/object/acl/v2/util_test.go
index e7fa444f36..8150fbedd3 100644
--- a/pkg/services/object/acl/v2/util_test.go
+++ b/pkg/services/object/acl/v2/util_test.go
@@ -6,14 +6,12 @@ import (
 	"crypto/rand"
 	"testing"
 
-	"github.com/nspcc-dev/neofs-api-go/v2/acl"
-	protoacl "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/session"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	bearertest "github.com/nspcc-dev/neofs-sdk-go/bearer/test"
 	aclsdk "github.com/nspcc-dev/neofs-sdk-go/container/acl"
 	cidtest "github.com/nspcc-dev/neofs-sdk-go/container/id/test"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
+	protoacl "github.com/nspcc-dev/neofs-sdk-go/proto/acl"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	sessionSDK "github.com/nspcc-dev/neofs-sdk-go/session"
 	sessiontest "github.com/nspcc-dev/neofs-sdk-go/session/test"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
@@ -29,17 +27,12 @@ func TestOriginalTokens(t *testing.T) {
 
 	require.NoError(t, bToken.Sign(signer))
 
-	var bTokenV2 acl.BearerToken
-	bToken.WriteToV2(&bTokenV2)
 	// This line is needed because SDK uses some custom format for
 	// reserved filters, so `cid.ID` is not converted to string immediately.
-	require.NoError(t, bToken.ReadFromV2(bTokenV2))
+	require.NoError(t, bToken.FromProtoMessage(bToken.ProtoMessage()))
 
-	var sTokenV2 session.Token
-	sToken.WriteToV2(&sTokenV2)
-
-	mbt := bTokenV2.ToGRPCMessage().(*protoacl.BearerToken)
-	mst := sTokenV2.ToGRPCMessage().(*protosession.SessionToken)
+	mbt := bToken.ProtoMessage()
+	mst := sToken.ProtoMessage()
 	for i := range 10 {
 		metaHeaders := testGenerateMetaHeader(uint32(i), mbt, mst)
 		res, err := originalSessionToken(metaHeaders)
@@ -55,13 +48,13 @@ func TestOriginalTokens(t *testing.T) {
 
 func testGenerateMetaHeader(depth uint32, b *protoacl.BearerToken, s *protosession.SessionToken) *protosession.RequestMetaHeader {
 	metaHeader := new(protosession.RequestMetaHeader)
-	metaHeader.SetBearerToken(b)
-	metaHeader.SetSessionToken(s)
+	metaHeader.BearerToken = b
+	metaHeader.SessionToken = s
 
 	for range depth {
 		link := metaHeader
 		metaHeader = new(protosession.RequestMetaHeader)
-		metaHeader.SetOrigin(link)
+		metaHeader.Origin = link
 	}
 
 	return metaHeader
diff --git a/pkg/services/object/get/assemble.go b/pkg/services/object/get/assemble.go
index ff98bf90ea..2a35703d36 100644
--- a/pkg/services/object/get/assemble.go
+++ b/pkg/services/object/get/assemble.go
@@ -203,11 +203,15 @@ func (exec *execCtx) buildChainInReverse(prev oid.ID) ([]oid.ID, []objectSDK.Ran
 		chain   = make([]oid.ID, 0)
 		rngs    = make([]objectSDK.Range, 0)
 		seekRng = exec.ctxRange()
-		from    = seekRng.GetOffset()
-		to      = from + seekRng.GetLength()
+		from    uint64
+		to      uint64
 
 		withPrev = true
 	)
+	if seekRng != nil {
+		from = seekRng.GetOffset()
+		to = from + seekRng.GetLength()
+	}
 
 	// fill the chain end-to-start
 	for withPrev {
diff --git a/pkg/services/object/internal/key.go b/pkg/services/object/internal/key.go
index 2d86353fea..ce86b6cfb7 100644
--- a/pkg/services/object/internal/key.go
+++ b/pkg/services/object/internal/key.go
@@ -3,13 +3,13 @@ package internal
 import (
 	"bytes"
 
-	session "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	"github.com/nspcc-dev/neofs-node/pkg/core/client"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 )
 
 // VerifyResponseKeyV2 checks if response is signed with expected key. Returns client.ErrWrongPublicKey if not.
 func VerifyResponseKeyV2(expectedKey []byte, resp interface {
-	GetVerifyHeader() *session.ResponseVerificationHeader
+	GetVerifyHeader() *protosession.ResponseVerificationHeader
 }) error {
 	if !bytes.Equal(resp.GetVerifyHeader().GetBodySignature().GetKey(), expectedKey) {
 		return client.ErrWrongPublicKey
diff --git a/pkg/services/object/put/distributed.go b/pkg/services/object/put/distributed.go
index a9adcffa29..6e2bc47d65 100644
--- a/pkg/services/object/put/distributed.go
+++ b/pkg/services/object/put/distributed.go
@@ -9,7 +9,6 @@ import (
 	"sync"
 	"sync/atomic"
 
-	"github.com/nspcc-dev/neofs-api-go/v2/refs"
 	"github.com/nspcc-dev/neofs-node/pkg/core/client"
 	"github.com/nspcc-dev/neofs-node/pkg/core/object"
 	chaincontainer "github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
@@ -278,14 +277,8 @@ func decodeSignature(b []byte) (neofscrypto.Signature, int, error) {
 		return neofscrypto.Signature{}, 0, fmt.Errorf("unexpected signature format: len: %d, len claimed: %d", len(b), l)
 	}
 
-	sig := new(refs.Signature)
-	err := sig.Unmarshal(b[4 : 4+l])
-	if err != nil {
-		return neofscrypto.Signature{}, 0, fmt.Errorf("decoding signature from proto message: %w", err)
-	}
-
 	var res neofscrypto.Signature
-	err = res.ReadFromV2(*sig)
+	err := res.Unmarshal(b[4 : 4+l])
 	if err != nil {
 		return neofscrypto.Signature{}, 0, fmt.Errorf("invalid signature: %w", err)
 	}
diff --git a/pkg/services/object/put/proto.go b/pkg/services/object/put/proto.go
index 3178cff6ea..1d3ce65583 100644
--- a/pkg/services/object/put/proto.go
+++ b/pkg/services/object/put/proto.go
@@ -44,8 +44,8 @@ type encodedObject struct {
 func encodeObjectWithoutPayload(hdr object.Object, pldLen int) (encodedObject, error) {
 	var res encodedObject
 
-	hdrv2 := hdr.ToV2()
-	hdrLen := hdrv2.StableSize()
+	hdrProto := hdr.ProtoMessage()
+	hdrLen := hdrProto.MarshaledSize()
 	pldFldLen := protowire.SizeTag(fieldNumObjectPayload) + protowire.SizeBytes(pldLen)
 	if pldFldLen > math.MaxInt-hdrLen {
 		return res, fmt.Errorf("binary object is too big for this server: %d+%d>%d", hdrLen, pldLen, math.MaxInt)
@@ -58,7 +58,7 @@ func encodeObjectWithoutPayload(hdr object.Object, pldLen int) (encodedObject, e
 	}
 
 	res.b = res.b[:hdrLen]
-	hdrv2.StableMarshal(res.b)
+	hdrProto.MarshalStable(res.b)
 	res.pldFldOff = len(res.b)
 	res.b = protowire.AppendTag(res.b, fieldNumObjectPayload, protowire.BytesType)
 	res.b = protowire.AppendVarint(res.b, uint64(pldLen))
@@ -79,8 +79,8 @@ func encodeReplicateRequestWithoutPayload(signer neofscrypto.Signer, hdr object.
 		return res, fmt.Errorf("sign object ID: %w", err)
 	}
 
-	hdrv2 := hdr.ToV2()
-	hdrLen := hdrv2.StableSize()
+	hdrProto := hdr.ProtoMessage()
+	hdrLen := hdrProto.MarshaledSize()
 	pldFldLen := protowire.SizeTag(fieldNumObjectPayload) + protowire.SizeBytes(pldLen)
 	if pldFldLen > math.MaxInt-hdrLen {
 		return res, fmt.Errorf("binary object is too big for this server: %d+%d>%d", hdrLen, pldFldLen, math.MaxInt)
@@ -124,7 +124,7 @@ func encodeReplicateRequestWithoutPayload(signer neofscrypto.Signer, hdr object.
 	res.b = protowire.AppendVarint(res.b, uint64(objFldLen))
 	res.hdrOff = len(res.b)
 	res.b = res.b[:len(res.b)+hdrLen]
-	hdrv2.StableMarshal(res.b[res.hdrOff:])
+	hdrProto.MarshalStable(res.b[res.hdrOff:])
 	res.pldFldOff = len(res.b)
 	res.b = protowire.AppendTag(res.b, fieldNumObjectPayload, protowire.BytesType)
 	res.b = protowire.AppendVarint(res.b, uint64(pldLen))
diff --git a/pkg/services/object/put/proto_test.go b/pkg/services/object/put/proto_test.go
index 34bf325248..492158bd4b 100644
--- a/pkg/services/object/put/proto_test.go
+++ b/pkg/services/object/put/proto_test.go
@@ -4,14 +4,12 @@ import (
 	"crypto/rand"
 	"testing"
 
-	objectv2 "github.com/nspcc-dev/neofs-api-go/v2/object"
-	objectgrpc "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/refs"
 	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
 	neofscryptotest "github.com/nspcc-dev/neofs-sdk-go/crypto/test"
 	"github.com/nspcc-dev/neofs-sdk-go/object"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
 	objecttest "github.com/nspcc-dev/neofs-sdk-go/object/test"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/proto"
 )
@@ -22,10 +20,10 @@ func TestUnaryReplicateRequest(t *testing.T) {
 	_, _ = rand.Read(payload)
 	obj := objecttest.Object()
 	obj.SetPayload(payload)
+	obj.SetPayloadSize(uint64(len(payload)))
 	id := oidtest.ID()
 	obj.SetID(id)
 	hdr := *obj.CutPayload()
-	obj.SetPayloadSize(uint64(len(payload)))
 	signer := neofscryptotest.Signer()
 
 	// prepare request
@@ -37,23 +35,20 @@ func TestUnaryReplicateRequest(t *testing.T) {
 	r.b = append(r.b, payload...)
 
 	// decode request
-	var req objectgrpc.ReplicateRequest
+	var req protoobject.ReplicateRequest
 	require.NoError(t, proto.Unmarshal(r.b, &req))
 
 	// check signature
 	require.Equal(t, neofscrypto.PublicKeyBytes(signer.Public()), req.Signature.Key)
 	require.EqualValues(t, signer.Scheme(), req.Signature.Scheme)
 
-	var sigv2 refs.Signature
-	require.NoError(t, sigv2.FromGRPCMessage(req.Signature))
 	var sig neofscrypto.Signature
-	require.NoError(t, sig.ReadFromV2(sigv2))
+	require.NoError(t, sig.FromProtoMessage(req.Signature))
 	require.True(t, sig.Verify(id[:]))
 
 	// check object
-	var objv2 objectv2.Object
-	require.NoError(t, objv2.FromGRPCMessage(req.Object))
-	obj2 := *object.NewFromV2(&objv2)
+	var obj2 object.Object
+	require.NoError(t, obj2.FromProtoMessage(req.Object))
 	require.Equal(t, obj, obj2)
 
 	// check meta signature flag
diff --git a/pkg/services/object/put/remote.go b/pkg/services/object/put/remote.go
index 256f7931dd..8101d12fd2 100644
--- a/pkg/services/object/put/remote.go
+++ b/pkg/services/object/put/remote.go
@@ -172,7 +172,7 @@ func (s *RemoteSender) ReplicateObjectToNode(ctx context.Context, id oid.ID, src
 		return fmt.Errorf("init NeoFS API client of the remote node: %w", err)
 	}
 
-	err = c.ReplicateObject(ctx, id, src, (*neofsecdsa.Signer)(key))
+	_, err = c.ReplicateObject(ctx, id, src, (*neofsecdsa.Signer)(key), false)
 	if err != nil {
 		return fmt.Errorf("copy object using NeoFS API client of the remote node: %w", err)
 	}
diff --git a/pkg/services/object/server.go b/pkg/services/object/server.go
index b1c5e638b8..da8d335b7e 100644
--- a/pkg/services/object/server.go
+++ b/pkg/services/object/server.go
@@ -13,14 +13,6 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	v2object "github.com/nspcc-dev/neofs-api-go/v2/object"
-	protoobject "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	refsv2 "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	"github.com/nspcc-dev/neofs-api-go/v2/status"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	"github.com/nspcc-dev/neofs-node/pkg/core/client"
 	"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	objectcore "github.com/nspcc-dev/neofs-node/pkg/core/object"
@@ -40,6 +32,10 @@ import (
 	neofsecdsa "github.com/nspcc-dev/neofs-sdk-go/crypto/ecdsa"
 	"github.com/nspcc-dev/neofs-sdk-go/object"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 	"github.com/nspcc-dev/neofs-sdk-go/stat"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
@@ -189,10 +185,7 @@ func (s *server) pushOpExecResult(op stat.Method, err error, startedAt time.Time
 }
 
 func newCurrentProtoVersionMessage() *refs.Version {
-	v := version.Current()
-	var v2 refsv2.Version
-	v.WriteToV2(&v2)
-	return v2.ToGRPCMessage().(*refs.Version)
+	return version.Current().ProtoMessage()
 }
 
 func (s *server) makeResponseMetaHeader(st *protostatus.Status) *protosession.ResponseMetaHeader {
@@ -204,7 +197,7 @@ func (s *server) makeResponseMetaHeader(st *protostatus.Status) *protosession.Re
 }
 
 func (s *server) sendPutResponse(stream protoobject.ObjectService_PutServer, resp *protoobject.PutResponse) error {
-	resp = util.SignResponse(&s.signer, resp, v2object.PutResponse{})
+	resp.VerifyHeader = util.SignResponse(&s.signer, resp)
 	return stream.SendAndClose(resp)
 }
 
@@ -283,11 +276,7 @@ func putToRemoteNode(ctx context.Context, c client.MultiAddressClient, addr netw
 	if err := internal.VerifyResponseKeyV2(nodePub, resp); err != nil {
 		return err
 	}
-	resp2 := new(v2object.PutResponse)
-	if err := resp2.FromGRPCMessage(resp); err != nil {
-		panic(err) // can only fail on wrong type, here it's correct
-	}
-	if err := signature.VerifyServiceMessage(resp2); err != nil {
+	if err := neofscrypto.VerifyResponseWithBuffer(resp, nil); err != nil {
 		return fmt.Errorf("response verification failed: %w", err)
 	}
 	if err := checkStatus(resp.GetMetaHeader().GetStatus()); err != nil {
@@ -298,18 +287,19 @@ func putToRemoteNode(ctx context.Context, c client.MultiAddressClient, addr netw
 
 func (x *putStream) resignRequest(req *protoobject.PutRequest) (*protoobject.PutRequest, error) {
 	meta := req.GetMetaHeader()
+	if meta == nil {
+		return nil, errors.New("missing meta header")
+	}
 	req.MetaHeader = &protosession.RequestMetaHeader{
 		Ttl:    meta.GetTtl() - 1,
 		Origin: meta,
 	}
-	var req2 v2object.PutRequest
-	if err := req2.FromGRPCMessage(req); err != nil {
-		panic(err)
-	}
-	if err := signature.SignServiceMessage(&x.signer, &req2); err != nil {
+	var err error
+	req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer(neofsecdsa.Signer(x.signer), req, nil)
+	if err != nil {
 		return nil, err
 	}
-	return req2.ToGRPCMessage().(*protoobject.PutRequest), nil
+	return req, nil
 }
 
 func (x *putStream) forwardRequest(req *protoobject.PutRequest) error {
@@ -331,11 +321,11 @@ func (x *putStream) forwardRequest(req *protoobject.PutRequest) error {
 			Signature: v.Init.Signature,
 			Header:    v.Init.Header,
 		}
-		var obj2 v2object.Object
-		if err := obj2.FromGRPCMessage(mo); err != nil {
-			panic(err)
+		var obj = new(object.Object)
+		err = obj.FromProtoMessage(mo)
+		if err != nil {
+			return err
 		}
-		obj := object.NewFromV2(&obj2)
 
 		var p putsvc.PutInitPrm
 		p.WithCommonPrm(cp)
@@ -360,7 +350,7 @@ func (x *putStream) forwardRequest(req *protoobject.PutRequest) error {
 		}
 		x.initReq = signed
 	case *protoobject.PutRequest_Body_Chunk:
-		c := v.GetChunk()
+		c := v.Chunk
 		if x.cacheReqs {
 			if x.recvBytes += uint64(len(c)); x.recvBytes > x.expBytes {
 				return putsvc.ErrWrongPayloadSize
@@ -392,11 +382,9 @@ func (x *putStream) close() (*protoobject.PutResponse, error) {
 	}
 
 	id := resp.ObjectID()
-	var id2 refsv2.ObjectID
-	id.WriteToV2(&id2)
 	return &protoobject.PutResponse{
 		Body: &protoobject.PutResponse_Body{
-			ObjectId: id2.ToGRPCMessage().(*refs.ObjectID),
+			ObjectId: id.ProtoMessage(),
 		},
 	}, nil
 }
@@ -432,11 +420,7 @@ func (s *server) Put(gStream protoobject.ObjectService_PutServer) error {
 			s.metrics.AddPutPayload(len(c))
 		}
 
-		putReq := new(v2object.PutRequest)
-		if err = putReq.FromGRPCMessage(req); err != nil {
-			return err
-		}
-		if err = signature.VerifyServiceMessage(putReq); err != nil {
+		if err = neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 			err = s.sendStatusPutResponse(gStream, util.ToRequestSignatureVerificationError(err)) // assign for defer
 			return err
 		}
@@ -473,7 +457,8 @@ func (s *server) Put(gStream protoobject.ObjectService_PutServer) error {
 }
 
 func (s *server) signDeleteResponse(resp *protoobject.DeleteResponse) *protoobject.DeleteResponse {
-	return util.SignResponse(&s.signer, resp, v2object.DeleteResponse{})
+	resp.VerifyHeader = util.SignResponse(&s.signer, resp)
+	return resp
 }
 
 func (s *server) makeStatusDeleteResponse(err error) *protoobject.DeleteResponse {
@@ -485,22 +470,17 @@ func (s *server) makeStatusDeleteResponse(err error) *protoobject.DeleteResponse
 type deleteResponseBody protoobject.DeleteResponse_Body
 
 func (x *deleteResponseBody) SetAddress(addr oid.Address) {
-	var addr2 refsv2.Address
-	addr.WriteToV2(&addr2)
-	x.Tombstone = addr2.ToGRPCMessage().(*refs.Address)
+	x.Tombstone = addr.ProtoMessage()
 }
 
 func (s *server) Delete(ctx context.Context, req *protoobject.DeleteRequest) (*protoobject.DeleteResponse, error) {
-	delReq := new(v2object.DeleteRequest)
-	err := delReq.FromGRPCMessage(req)
-	if err != nil {
-		return nil, err
-	}
-
-	t := time.Now()
+	var (
+		err error
+		t   = time.Now()
+	)
 	defer func() { s.pushOpExecResult(stat.MethodObjectDelete, err, t) }()
 
-	if err = signature.VerifyServiceMessage(delReq); err != nil {
+	if err = neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeStatusDeleteResponse(err), nil
 	}
 
@@ -527,11 +507,7 @@ func (s *server) Delete(ctx context.Context, req *protoobject.DeleteRequest) (*p
 		return s.makeStatusDeleteResponse(errors.New("missing object address")), nil
 	}
 	var addr oid.Address
-	var addr2 refsv2.Address
-	if err := addr2.FromGRPCMessage(ma); err != nil {
-		panic(err)
-	}
-	err = addr.ReadFromV2(addr2)
+	err = addr.FromProtoMessage(ma)
 	if err != nil {
 		return s.makeStatusDeleteResponse(fmt.Errorf("invalid object address: %w", err)), nil
 	}
@@ -556,7 +532,8 @@ func (s *server) Delete(ctx context.Context, req *protoobject.DeleteRequest) (*p
 }
 
 func (s *server) signHeadResponse(resp *protoobject.HeadResponse) *protoobject.HeadResponse {
-	return util.SignResponse(&s.signer, resp, v2object.HeadResponse{})
+	resp.VerifyHeader = util.SignResponse(&s.signer, resp)
+	return resp
 }
 
 func (s *server) makeStatusHeadResponse(err error) *protoobject.HeadResponse {
@@ -565,7 +542,7 @@ func (s *server) makeStatusHeadResponse(err error) *protoobject.HeadResponse {
 		return s.signHeadResponse(&protoobject.HeadResponse{
 			Body: &protoobject.HeadResponse_Body{
 				Head: &protoobject.HeadResponse_Body_SplitInfo{
-					SplitInfo: splitErr.SplitInfo().ToV2().ToGRPCMessage().(*protoobject.SplitInfo),
+					SplitInfo: splitErr.SplitInfo().ProtoMessage(),
 				},
 			},
 		})
@@ -576,16 +553,13 @@ func (s *server) makeStatusHeadResponse(err error) *protoobject.HeadResponse {
 }
 
 func (s *server) Head(ctx context.Context, req *protoobject.HeadRequest) (*protoobject.HeadResponse, error) {
-	searchReq := new(v2object.HeadRequest)
-	err := searchReq.FromGRPCMessage(req)
-	if err != nil {
-		return nil, err
-	}
-
-	t := time.Now()
+	var (
+		err error
+		t   = time.Now()
+	)
 	defer func() { s.pushOpExecResult(stat.MethodObjectHead, err, t) }()
 
-	if err = signature.VerifyServiceMessage(searchReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeStatusHeadResponse(err), nil
 	}
 
@@ -632,7 +606,7 @@ type headResponse struct {
 }
 
 func (x *headResponse) WriteHeader(hdr *object.Object) error {
-	mo := hdr.ToV2().ToGRPCMessage().(*protoobject.Object)
+	mo := hdr.ProtoMessage()
 	if x.short {
 		mh := mo.GetHeader()
 		x.dst.Body = &protoobject.HeadResponse_Body{
@@ -671,11 +645,7 @@ func convertHeadPrm(signer ecdsa.PrivateKey, req *protoobject.HeadRequest, resp
 	}
 
 	var addr oid.Address
-	var addr2 refsv2.Address
-	if err := addr2.FromGRPCMessage(ma); err != nil {
-		panic(err)
-	}
-	if err := addr.ReadFromV2(addr2); err != nil {
+	if err := addr.FromProtoMessage(ma); err != nil {
 		return getsvc.HeadPrm{}, fmt.Errorf("invalid object address: %w", err)
 	}
 
@@ -710,13 +680,7 @@ func convertHeadPrm(signer ecdsa.PrivateKey, req *protoobject.HeadRequest, resp
 				Ttl:    meta.GetTtl() - 1,
 				Origin: meta,
 			}
-			var req2 v2object.HeadRequest
-			if err := req2.FromGRPCMessage(req); err != nil {
-				panic(err)
-			}
-			if err = signature.SignServiceMessage(&signer, &req2); err == nil {
-				req = req2.ToGRPCMessage().(*protoobject.HeadRequest)
-			}
+			req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer(neofsecdsa.Signer(signer), req, nil)
 		})
 		if err != nil {
 			return nil, err
@@ -756,11 +720,7 @@ func getHeaderFromRemoteNode(ctx context.Context, c client.MultiAddressClient, a
 	if err := internal.VerifyResponseKeyV2(nodePub, resp); err != nil {
 		return nil, err
 	}
-	resp2 := new(v2object.HeadResponse)
-	if err := resp2.FromGRPCMessage(resp); err != nil {
-		panic(err) // can only fail on wrong type, here it's correct
-	}
-	if err := signature.VerifyServiceMessage(resp2); err != nil {
+	if err := neofscrypto.VerifyResponseWithBuffer(resp, nil); err != nil {
 		return nil, fmt.Errorf("response verification failed: %w", err)
 	}
 	if err := checkStatus(resp.GetMetaHeader().GetStatus()); err != nil {
@@ -808,12 +768,8 @@ func getHeaderFromRemoteNode(ctx context.Context, c client.MultiAddressClient, a
 			return nil, errors.New("missing signature")
 		}
 
-		var sig2 refsv2.Signature
-		if err := sig2.FromGRPCMessage(v.Header.Signature); err != nil {
-			panic(err) // can only fail on wrong type, here it's correct
-		}
 		var sig neofscrypto.Signature
-		if err := sig.ReadFromV2(sig2); err != nil {
+		if err := sig.FromProtoMessage(v.Header.Signature); err != nil {
 			return nil, fmt.Errorf("can't read signature: %w", err)
 		}
 		if !sig.Verify(bID) {
@@ -826,11 +782,11 @@ func getHeaderFromRemoteNode(ctx context.Context, c client.MultiAddressClient, a
 		if v == nil || v.SplitInfo == nil {
 			return nil, errors.New("nil split info oneof field")
 		}
-		var si2 v2object.SplitInfo
-		if err := si2.FromGRPCMessage(v.SplitInfo); err != nil {
-			panic(err) // can only fail on wrong type, here it's correct
+		si := object.NewSplitInfo()
+		err := si.FromProtoMessage(v.SplitInfo)
+		if err != nil {
+			return nil, err
 		}
-		si := object.NewSplitInfoFromV2(&si2)
 		return nil, object.NewSplitInfoError(si)
 	}
 
@@ -838,15 +794,16 @@ func getHeaderFromRemoteNode(ctx context.Context, c client.MultiAddressClient, a
 		Signature: idSig,
 		Header:    hdr,
 	}
-	objv2 := new(v2object.Object)
-	if err := objv2.FromGRPCMessage(mObj); err != nil {
-		panic(err) // can only fail on wrong type, here it's correct
+	var obj = object.New()
+	if err := obj.FromProtoMessage(mObj); err != nil {
+		return nil, err
 	}
-	return object.NewFromV2(objv2), nil
+	return obj, nil
 }
 
 func (s *server) signHashResponse(resp *protoobject.GetRangeHashResponse) *protoobject.GetRangeHashResponse {
-	return util.SignResponse(&s.signer, resp, v2object.GetRangeHashResponse{})
+	resp.VerifyHeader = util.SignResponse(&s.signer, resp)
+	return resp
 }
 
 func (s *server) makeStatusHashResponse(err error) *protoobject.GetRangeHashResponse {
@@ -857,15 +814,12 @@ func (s *server) makeStatusHashResponse(err error) *protoobject.GetRangeHashResp
 
 // GetRangeHash converts gRPC GetRangeHashRequest message and passes it to internal Object service.
 func (s *server) GetRangeHash(ctx context.Context, req *protoobject.GetRangeHashRequest) (*protoobject.GetRangeHashResponse, error) {
-	hashRngReq := new(v2object.GetRangeHashRequest)
-	err := hashRngReq.FromGRPCMessage(req)
-	if err != nil {
-		return nil, err
-	}
-
-	t := time.Now()
+	var (
+		err error
+		t   = time.Now()
+	)
 	defer func() { s.pushOpExecResult(stat.MethodObjectHash, err, t) }()
-	if err = signature.VerifyServiceMessage(hashRngReq); err != nil {
+	if err = neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeStatusHashResponse(err), nil
 	}
 
@@ -912,11 +866,7 @@ func convertHashPrm(signer ecdsa.PrivateKey, ss sessions, req *protoobject.GetRa
 	}
 
 	var addr oid.Address
-	var addr2 refsv2.Address
-	if err := addr2.FromGRPCMessage(ma); err != nil {
-		panic(err)
-	}
-	if err := addr.ReadFromV2(addr2); err != nil {
+	if err := addr.FromProtoMessage(ma); err != nil {
 		return getsvc.RangeHashPrm{}, fmt.Errorf("invalid object address: %w", err)
 	}
 
@@ -951,11 +901,8 @@ func convertHashPrm(signer ecdsa.PrivateKey, ss sessions, req *protoobject.GetRa
 	mr := body.GetRanges()
 	rngs := make([]object.Range, len(mr))
 	for i := range mr {
-		var r2 v2object.Range
-		if err := r2.FromGRPCMessage(mr[i]); err != nil {
-			panic(err)
-		}
-		rngs[i] = *object.NewRangeFromV2(&r2)
+		rngs[i].SetOffset(mr[i].Offset)
+		rngs[i].SetLength(mr[i].Length)
 	}
 
 	p.SetCommonParameters(cp)
@@ -981,13 +928,7 @@ func convertHashPrm(signer ecdsa.PrivateKey, ss sessions, req *protoobject.GetRa
 				Ttl:     meta.GetTtl() - 1,
 				Origin:  meta,
 			}
-			var req2 v2object.GetRangeHashRequest
-			if err := req2.FromGRPCMessage(req); err != nil {
-				panic(err)
-			}
-			if err = signature.SignServiceMessage(&signer, &req2); err == nil {
-				req = req2.ToGRPCMessage().(*protoobject.GetRangeHashRequest)
-			}
+			req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer(neofsecdsa.Signer(signer), req, nil)
 		})
 		if err != nil {
 			return nil, err
@@ -1026,11 +967,7 @@ func getHashesFromRemoteNode(ctx context.Context, c client.MultiAddressClient, a
 	if err := internal.VerifyResponseKeyV2(nodePub, resp); err != nil {
 		return nil, err
 	}
-	resp2 := new(v2object.GetRangeHashResponse)
-	if err := resp2.FromGRPCMessage(resp); err != nil {
-		panic(err) // can only fail on wrong type, here it's correct
-	}
-	if err := signature.VerifyServiceMessage(resp2); err != nil {
+	if err := neofscrypto.VerifyResponseWithBuffer(resp, nil); err != nil {
 		return nil, fmt.Errorf("response verification failed: %w", err)
 	}
 	if err := checkStatus(resp.GetMetaHeader().GetStatus()); err != nil {
@@ -1041,7 +978,8 @@ func getHashesFromRemoteNode(ctx context.Context, c client.MultiAddressClient, a
 }
 
 func (s *server) sendGetResponse(stream protoobject.ObjectService_GetServer, resp *protoobject.GetResponse) error {
-	return stream.Send(util.SignResponse(&s.signer, resp, v2object.GetResponse{}))
+	resp.VerifyHeader = util.SignResponse(&s.signer, resp)
+	return stream.Send(resp)
 }
 
 func (s *server) sendStatusGetResponse(stream protoobject.ObjectService_GetServer, err error) error {
@@ -1050,7 +988,7 @@ func (s *server) sendStatusGetResponse(stream protoobject.ObjectService_GetServe
 		return s.sendGetResponse(stream, &protoobject.GetResponse{
 			Body: &protoobject.GetResponse_Body{
 				ObjectPart: &protoobject.GetResponse_Body_SplitInfo{
-					SplitInfo: splitErr.SplitInfo().ToV2().ToGRPCMessage().(*protoobject.SplitInfo),
+					SplitInfo: splitErr.SplitInfo().ProtoMessage(),
 				},
 			},
 		})
@@ -1067,7 +1005,7 @@ type getStream struct {
 }
 
 func (s *getStream) WriteHeader(hdr *object.Object) error {
-	mo := hdr.ToV2().ToGRPCMessage().(*protoobject.Object)
+	mo := hdr.ProtoMessage()
 	resp := &protoobject.GetResponse{
 		Body: &protoobject.GetResponse_Body{
 			ObjectPart: &protoobject.GetResponse_Body_Init_{Init: &protoobject.GetResponse_Body_Init{
@@ -1101,14 +1039,12 @@ func (s *getStream) WriteChunk(chunk []byte) error {
 }
 
 func (s *server) Get(req *protoobject.GetRequest, gStream protoobject.ObjectService_GetServer) error {
-	getReq := new(v2object.GetRequest)
-	err := getReq.FromGRPCMessage(req)
-	if err != nil {
-		return err
-	}
-	t := time.Now()
+	var (
+		err error
+		t   = time.Now()
+	)
 	defer func() { s.pushOpExecResult(stat.MethodObjectGet, err, t) }()
-	if err = signature.VerifyServiceMessage(getReq); err != nil {
+	if err = neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.sendStatusGetResponse(gStream, err)
 	}
 
@@ -1156,11 +1092,7 @@ func convertGetPrm(signer ecdsa.PrivateKey, req *protoobject.GetRequest, stream
 	}
 
 	var addr oid.Address
-	var addr2 refsv2.Address
-	if err := addr2.FromGRPCMessage(ma); err != nil {
-		panic(err)
-	}
-	if err := addr.ReadFromV2(addr2); err != nil {
+	if err := addr.FromProtoMessage(ma); err != nil {
 		return getsvc.Prm{}, fmt.Errorf("invalid object address: %w", err)
 	}
 
@@ -1193,13 +1125,7 @@ func convertGetPrm(signer ecdsa.PrivateKey, req *protoobject.GetRequest, stream
 				Ttl:    meta.GetTtl() - 1,
 				Origin: meta,
 			}
-			var req2 v2object.GetRequest
-			if err := req2.FromGRPCMessage(req); err != nil {
-				panic(err)
-			}
-			if err = signature.SignServiceMessage(&signer, &req2); err == nil {
-				req = req2.ToGRPCMessage().(*protoobject.GetRequest)
-			}
+			req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer(neofsecdsa.Signer(signer), req, nil)
 		})
 		if err != nil {
 			return nil, err
@@ -1253,11 +1179,7 @@ func continueGetFromRemoteNode(ctx context.Context, c client.MultiAddressClient,
 		if err = internal.VerifyResponseKeyV2(nodePub, resp); err != nil {
 			return err
 		}
-		resp2 := new(v2object.GetResponse)
-		if err := resp2.FromGRPCMessage(resp); err != nil {
-			panic(err) // can only fail on wrong type, here it's correct
-		}
-		if err := signature.VerifyServiceMessage(resp2); err != nil {
+		if err := neofscrypto.VerifyResponseWithBuffer(resp, nil); err != nil {
 			return fmt.Errorf("response verification failed: %w", err)
 		}
 		if err := checkStatus(resp.GetMetaHeader().GetStatus()); err != nil {
@@ -1280,12 +1202,13 @@ func continueGetFromRemoteNode(ctx context.Context, c client.MultiAddressClient,
 				Signature: v.Init.Signature,
 				Header:    v.Init.Header,
 			}
-			obj := new(v2object.Object)
-			if err := obj.FromGRPCMessage(mo); err != nil {
-				panic(err) // can only fail on wrong type, here it's correct
+			obj := object.New()
+			err := obj.FromProtoMessage(mo)
+			if err != nil {
+				return err
 			}
 			onceHdr.Do(func() {
-				err = stream.WriteHeader(object.NewFromV2(obj))
+				err = stream.WriteHeader(obj)
 			})
 			if err != nil {
 				return fmt.Errorf("could not write object header in Get forwarder: %w", err)
@@ -1294,7 +1217,7 @@ func continueGetFromRemoteNode(ctx context.Context, c client.MultiAddressClient,
 			if !headWas {
 				return errors.New("incorrect message sequence")
 			}
-			fullChunk := v.GetChunk()
+			fullChunk := v.Chunk
 			respChunk := chunkToSend(*respondedPayload, readPayload, fullChunk)
 			if len(respChunk) == 0 {
 				readPayload += len(fullChunk)
@@ -1309,18 +1232,19 @@ func continueGetFromRemoteNode(ctx context.Context, c client.MultiAddressClient,
 			if v == nil || v.SplitInfo == nil {
 				return errors.New("nil split info oneof field")
 			}
-			var si2 v2object.SplitInfo
-			if err := si2.FromGRPCMessage(v.SplitInfo); err != nil {
-				panic(err) // can only fail on wrong type, here it's correct
+			si := object.NewSplitInfo()
+			err := si.FromProtoMessage(v.SplitInfo)
+			if err != nil {
+				return err
 			}
-			si := object.NewSplitInfoFromV2(&si2)
 			return object.NewSplitInfoError(si)
 		}
 	}
 }
 
 func (s *server) sendRangeResponse(stream protoobject.ObjectService_GetRangeServer, resp *protoobject.GetRangeResponse) error {
-	return stream.Send(util.SignResponse(&s.signer, resp, v2object.GetRangeResponse{}))
+	resp.VerifyHeader = util.SignResponse(&s.signer, resp)
+	return stream.Send(resp)
 }
 
 func (s *server) sendStatusRangeResponse(stream protoobject.ObjectService_GetRangeServer, err error) error {
@@ -1329,7 +1253,7 @@ func (s *server) sendStatusRangeResponse(stream protoobject.ObjectService_GetRan
 		return s.sendRangeResponse(stream, &protoobject.GetRangeResponse{
 			Body: &protoobject.GetRangeResponse_Body{
 				RangePart: &protoobject.GetRangeResponse_Body_SplitInfo{
-					SplitInfo: splitErr.SplitInfo().ToV2().ToGRPCMessage().(*protoobject.SplitInfo),
+					SplitInfo: splitErr.SplitInfo().ProtoMessage(),
 				},
 			},
 		})
@@ -1367,14 +1291,12 @@ func (s *rangeStream) WriteChunk(chunk []byte) error {
 }
 
 func (s *server) GetRange(req *protoobject.GetRangeRequest, gStream protoobject.ObjectService_GetRangeServer) error {
-	getRngReq := new(v2object.GetRangeRequest)
-	err := getRngReq.FromGRPCMessage(req)
-	if err != nil {
-		return err
-	}
-	t := time.Now()
+	var (
+		err error
+		t   = time.Now()
+	)
 	defer func() { s.pushOpExecResult(stat.MethodObjectRange, err, t) }()
-	if err = signature.VerifyServiceMessage(getRngReq); err != nil {
+	if err = neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.sendStatusRangeResponse(gStream, err)
 	}
 
@@ -1422,11 +1344,7 @@ func convertRangePrm(signer ecdsa.PrivateKey, req *protoobject.GetRangeRequest,
 	}
 
 	var addr oid.Address
-	var addr2 refsv2.Address
-	if err := addr2.FromGRPCMessage(ma); err != nil {
-		panic(err)
-	}
-	if err := addr.ReadFromV2(addr2); err != nil {
+	if err := addr.FromProtoMessage(ma); err != nil {
 		return getsvc.RangePrm{}, fmt.Errorf("invalid object address: %w", err)
 	}
 
@@ -1470,13 +1388,7 @@ func convertRangePrm(signer ecdsa.PrivateKey, req *protoobject.GetRangeRequest,
 				Ttl:    meta.GetTtl() - 1,
 				Origin: meta,
 			}
-			var req2 v2object.GetRangeRequest
-			if err := req2.FromGRPCMessage(req); err != nil {
-				panic(err)
-			}
-			if err = signature.SignServiceMessage(&signer, &req2); err == nil {
-				req = req2.ToGRPCMessage().(*protoobject.GetRangeRequest)
-			}
+			req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer(neofsecdsa.Signer(signer), req, nil)
 		})
 		if err != nil {
 			return nil, err
@@ -1526,11 +1438,7 @@ func continueRangeFromRemoteNode(ctx context.Context, c client.MultiAddressClien
 		if err = internal.VerifyResponseKeyV2(nodePub, resp); err != nil {
 			return err
 		}
-		resp2 := new(v2object.GetRangeResponse)
-		if err := resp2.FromGRPCMessage(resp); err != nil {
-			panic(err) // can only fail on wrong type, here it's correct
-		}
-		if err := signature.VerifyServiceMessage(resp2); err != nil {
+		if err := neofscrypto.VerifyResponseWithBuffer(resp, nil); err != nil {
 			return fmt.Errorf("response verification failed: %w", err)
 		}
 		if err := checkStatus(resp.GetMetaHeader().GetStatus()); err != nil {
@@ -1541,7 +1449,7 @@ func continueRangeFromRemoteNode(ctx context.Context, c client.MultiAddressClien
 		default:
 			return fmt.Errorf("unexpected range type %T", v)
 		case *protoobject.GetRangeResponse_Body_Chunk:
-			fullChunk := v.GetChunk()
+			fullChunk := v.Chunk
 			respChunk := chunkToSend(*respondedPayload, readPayload, fullChunk)
 			if len(respChunk) == 0 {
 				readPayload += len(fullChunk)
@@ -1556,18 +1464,19 @@ func continueRangeFromRemoteNode(ctx context.Context, c client.MultiAddressClien
 			if v == nil || v.SplitInfo == nil {
 				return errors.New("nil split info oneof field")
 			}
-			var si2 v2object.SplitInfo
-			if err := si2.FromGRPCMessage(v.SplitInfo); err != nil {
-				panic(err) // can only fail on wrong type, here it's correct
+			si := object.NewSplitInfo()
+			err := si.FromProtoMessage(v.SplitInfo)
+			if err != nil {
+				return err
 			}
-			si := object.NewSplitInfoFromV2(&si2)
 			return object.NewSplitInfoError(si)
 		}
 	}
 }
 
 func (s *server) sendSearchResponse(stream protoobject.ObjectService_SearchServer, resp *protoobject.SearchResponse) error {
-	return stream.Send(util.SignResponse(&s.signer, resp, v2object.SearchResponse{}))
+	resp.VerifyHeader = util.SignResponse(&s.signer, resp)
+	return stream.Send(resp)
 }
 
 func (s *server) sendStatusSearchResponse(stream protoobject.ObjectService_SearchServer, err error) error {
@@ -1595,10 +1504,8 @@ func (s *searchStream) WriteIDs(ids []oid.ID) error {
 		}
 
 		r.Body.IdList = make([]*refs.ObjectID, cut)
-		var id2 refsv2.ObjectID
 		for i := range cut {
-			ids[i].WriteToV2(&id2)
-			r.Body.IdList[i] = id2.ToGRPCMessage().(*refs.ObjectID)
+			r.Body.IdList[i] = ids[i].ProtoMessage()
 		}
 		// TODO: do not check response multiple times
 		// TODO: why check it at all?
@@ -1615,14 +1522,12 @@ func (s *searchStream) WriteIDs(ids []oid.ID) error {
 }
 
 func (s *server) Search(req *protoobject.SearchRequest, gStream protoobject.ObjectService_SearchServer) error {
-	searchReq := new(v2object.SearchRequest)
-	err := searchReq.FromGRPCMessage(req)
-	if err != nil {
-		return err
-	}
-	t := time.Now()
+	var (
+		err error
+		t   = time.Now()
+	)
 	defer func() { s.pushOpExecResult(stat.MethodObjectSearch, err, t) }()
-	if err = signature.VerifyServiceMessage(searchReq); err != nil {
+	if err = neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.sendStatusSearchResponse(gStream, err)
 	}
 
@@ -1670,11 +1575,7 @@ func convertSearchPrm(ctx context.Context, signer ecdsa.PrivateKey, req *protoob
 	}
 
 	var id cid.ID
-	var id2 refsv2.ContainerID
-	if err := id2.FromGRPCMessage(mc); err != nil {
-		panic(err)
-	}
-	if err := id.ReadFromV2(id2); err != nil {
+	if err := id.FromProtoMessage(mc); err != nil {
 		return searchsvc.Prm{}, fmt.Errorf("invalid container ID: %w", err)
 	}
 
@@ -1684,17 +1585,16 @@ func convertSearchPrm(ctx context.Context, signer ecdsa.PrivateKey, req *protoob
 	}
 
 	mfs := body.GetFilters()
-	fs2 := make([]v2object.SearchFilter, len(mfs))
-	for i := range mfs {
-		if err := fs2[i].FromGRPCMessage(mfs[i]); err != nil {
-			panic(err)
-		}
+	ofs := object.NewSearchFilters()
+	err = ofs.FromProtoMessage(mfs)
+	if err != nil {
+		return searchsvc.Prm{}, err
 	}
 
 	var p searchsvc.Prm
 	p.SetCommonParameters(cp)
 	p.WithContainerID(id)
-	p.WithSearchFilters(object.NewSearchFiltersFromV2(fs2))
+	p.WithSearchFilters(ofs)
 	p.SetWriter(stream)
 	if cp.LocalOnly() {
 		return p, nil
@@ -1713,13 +1613,7 @@ func convertSearchPrm(ctx context.Context, signer ecdsa.PrivateKey, req *protoob
 				Ttl:    meta.GetTtl() - 1,
 				Origin: meta,
 			}
-			var req2 v2object.SearchRequest
-			if err := req2.FromGRPCMessage(req); err != nil {
-				panic(err)
-			}
-			if err = signature.SignServiceMessage(&signer, &req2); err == nil {
-				req = req2.ToGRPCMessage().(*protoobject.SearchRequest)
-			}
+			req.VerifyHeader, err = neofscrypto.SignRequestWithBuffer(neofsecdsa.Signer(signer), req, nil)
 		})
 		if err != nil {
 			return nil, err
@@ -1766,11 +1660,7 @@ func searchOnRemoteNode(ctx context.Context, c client.MultiAddressClient, addr n
 		if err := internal.VerifyResponseKeyV2(nodePub, resp); err != nil {
 			return nil, err
 		}
-		resp2 := new(v2object.SearchResponse)
-		if err := resp2.FromGRPCMessage(resp); err != nil {
-			panic(err) // can only fail on wrong type, here it's correct
-		}
-		if err := signature.VerifyServiceMessage(resp2); err != nil {
+		if err := neofscrypto.VerifyResponseWithBuffer(resp, nil); err != nil {
 			return nil, fmt.Errorf("could not verify %T: %w", resp, err)
 		}
 		if err := checkStatus(resp.GetMetaHeader().GetStatus()); err != nil {
@@ -1780,11 +1670,7 @@ func searchOnRemoteNode(ctx context.Context, c client.MultiAddressClient, addr n
 		chunk := resp.GetBody().GetIdList()
 		var id oid.ID
 		for i := range chunk {
-			var id2 refsv2.ObjectID
-			if err := id2.FromGRPCMessage(chunk[i]); err != nil {
-				panic(err) // can only fail on wrong type, here it's correct
-			}
-			if err := id.ReadFromV2(id2); err != nil {
+			if err := id.FromProtoMessage(chunk[i]); err != nil {
 				return nil, fmt.Errorf("invalid object ID: %w", err)
 			}
 			res = append(res, id)
@@ -1853,11 +1739,7 @@ func (s *server) Replicate(_ context.Context, req *protoobject.ReplicateRequest)
 	}
 
 	var cnr cid.ID
-	var cnrMsg refsv2.ContainerID
-	err := cnrMsg.FromGRPCMessage(gCnrMsg)
-	if err == nil {
-		err = cnr.ReadFromV2(cnrMsg)
-	}
+	err := cnr.FromProtoMessage(gCnrMsg)
 	if err != nil {
 		return &protoobject.ReplicateResponse{Status: &protostatus.Status{
 			Code:    codeInternal,
@@ -1966,14 +1848,18 @@ func (s *server) Replicate(_ context.Context, req *protoobject.ReplicateRequest)
 	return resp, nil
 }
 
+func (s *server) SearchV2(_ context.Context, _ *protoobject.SearchV2Request) (*protoobject.SearchV2Response, error) {
+	return nil, errors.New("unimplemented")
+}
+
 func objectFromMessage(gMsg *protoobject.Object) (*object.Object, error) {
-	var msg v2object.Object
-	err := msg.FromGRPCMessage(gMsg)
+	var obj = object.New()
+	err := obj.FromProtoMessage(gMsg)
 	if err != nil {
 		return nil, err
 	}
 
-	return object.NewFromV2(&msg), nil
+	return obj, nil
 }
 
 func (s *server) metaInfoSignature(o object.Object) ([]byte, error) {
@@ -2035,34 +1921,23 @@ func (s *server) metaInfoSignature(o object.Object) ([]byte, error) {
 		return nil, fmt.Errorf("signature failure: %w", err)
 	}
 
-	firstSigV2 := new(refsv2.Signature)
-	firstSig.WriteToV2(firstSigV2)
-	secondSigV2 := new(refsv2.Signature)
-	secondSig.WriteToV2(secondSigV2)
-	thirdSigV2 := new(refsv2.Signature)
-	thirdSig.WriteToV2(thirdSigV2)
+	firstSigV2 := firstSig.ProtoMessage()
+	secondSigV2 := secondSig.ProtoMessage()
+	thirdSigV2 := thirdSig.ProtoMessage()
 
-	res := make([]byte, 0, 4+firstSigV2.StableSize()+4+secondSigV2.StableSize()+4+thirdSigV2.StableSize())
-	res = binary.LittleEndian.AppendUint32(res, uint32(firstSigV2.StableSize()))
-	res = append(res, firstSigV2.StableMarshal(nil)...)
-	res = binary.LittleEndian.AppendUint32(res, uint32(secondSigV2.StableSize()))
-	res = append(res, secondSigV2.StableMarshal(nil)...)
-	res = binary.LittleEndian.AppendUint32(res, uint32(thirdSigV2.StableSize()))
-	res = append(res, thirdSigV2.StableMarshal(nil)...)
+	res := make([]byte, 4+firstSigV2.MarshaledSize()+4+secondSigV2.MarshaledSize()+4+thirdSigV2.MarshaledSize())
+	binary.LittleEndian.PutUint32(res, uint32(firstSigV2.MarshaledSize()))
+	firstSigV2.MarshalStable(res[4 : 4+firstSigV2.MarshaledSize()])
+	binary.LittleEndian.PutUint32(res[4+firstSigV2.MarshaledSize():], uint32(secondSigV2.MarshaledSize()))
+	secondSigV2.MarshalStable(res[4+firstSigV2.MarshaledSize()+4 : 4+firstSigV2.MarshaledSize()+4+secondSigV2.MarshaledSize()])
+	binary.LittleEndian.PutUint32(res[4+firstSigV2.MarshaledSize()+4+secondSigV2.MarshaledSize():], uint32(thirdSigV2.MarshaledSize()))
+	thirdSigV2.MarshalStable(res[4+firstSigV2.MarshaledSize()+4+secondSigV2.MarshaledSize()+4:])
 
 	return res, nil
 }
 
 func checkStatus(st *protostatus.Status) error {
-	stV2 := new(status.Status)
-	if err := stV2.FromGRPCMessage(st); err != nil {
-		panic(err) // can only fail on wrong type, here it's correct
-	}
-	if !status.IsSuccess(stV2.Code()) {
-		return apistatus.ErrorFromV2(stV2)
-	}
-
-	return nil
+	return apistatus.ToError(st)
 }
 
 func chunkToSend(global, local int, chunk []byte) []byte {
diff --git a/pkg/services/object/server_test.go b/pkg/services/object/server_test.go
index 6d7ac363a2..dfe8a0abbd 100644
--- a/pkg/services/object/server_test.go
+++ b/pkg/services/object/server_test.go
@@ -13,9 +13,6 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	objectgrpc "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
-	refsv2 "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
 	objectcore "github.com/nspcc-dev/neofs-node/pkg/core/object"
 	. "github.com/nspcc-dev/neofs-node/pkg/services/object"
 	v2 "github.com/nspcc-dev/neofs-node/pkg/services/object/acl/v2"
@@ -33,6 +30,8 @@ import (
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
 	objecttest "github.com/nspcc-dev/neofs-sdk-go/object/test"
+	protoobject "github.com/nspcc-dev/neofs-sdk-go/proto/object"
+	"github.com/nspcc-dev/neofs-sdk-go/proto/refs"
 	"github.com/nspcc-dev/neofs-sdk-go/stat"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/stretchr/testify/require"
@@ -102,25 +101,25 @@ func (noCallTestACLChecker) StickyBitCheck(v2.RequestInfo, user.ID) bool { panic
 
 type noCallTestReqInfoExtractor struct{}
 
-func (noCallTestReqInfoExtractor) PutRequestToInfo(*objectgrpc.PutRequest) (v2.RequestInfo, user.ID, error) {
+func (noCallTestReqInfoExtractor) PutRequestToInfo(*protoobject.PutRequest) (v2.RequestInfo, user.ID, error) {
 	panic("must not be called")
 }
-func (noCallTestReqInfoExtractor) DeleteRequestToInfo(*objectgrpc.DeleteRequest) (v2.RequestInfo, error) {
+func (noCallTestReqInfoExtractor) DeleteRequestToInfo(*protoobject.DeleteRequest) (v2.RequestInfo, error) {
 	panic("must not be called")
 }
-func (noCallTestReqInfoExtractor) HeadRequestToInfo(*objectgrpc.HeadRequest) (v2.RequestInfo, error) {
+func (noCallTestReqInfoExtractor) HeadRequestToInfo(*protoobject.HeadRequest) (v2.RequestInfo, error) {
 	panic("must not be called")
 }
-func (noCallTestReqInfoExtractor) HashRequestToInfo(*objectgrpc.GetRangeHashRequest) (v2.RequestInfo, error) {
+func (noCallTestReqInfoExtractor) HashRequestToInfo(*protoobject.GetRangeHashRequest) (v2.RequestInfo, error) {
 	panic("must not be called")
 }
-func (noCallTestReqInfoExtractor) GetRequestToInfo(*objectgrpc.GetRequest) (v2.RequestInfo, error) {
+func (noCallTestReqInfoExtractor) GetRequestToInfo(*protoobject.GetRequest) (v2.RequestInfo, error) {
 	panic("must not be called")
 }
-func (noCallTestReqInfoExtractor) RangeRequestToInfo(*objectgrpc.GetRangeRequest) (v2.RequestInfo, error) {
+func (noCallTestReqInfoExtractor) RangeRequestToInfo(*protoobject.GetRangeRequest) (v2.RequestInfo, error) {
 	panic("must not be called")
 }
-func (noCallTestReqInfoExtractor) SearchRequestToInfo(*objectgrpc.SearchRequest) (v2.RequestInfo, error) {
+func (noCallTestReqInfoExtractor) SearchRequestToInfo(*protoobject.SearchRequest) (v2.RequestInfo, error) {
 	panic("must not be called")
 }
 
@@ -132,25 +131,25 @@ func (nopACLChecker) StickyBitCheck(v2.RequestInfo, user.ID) bool { return true
 
 type nopReqInfoExtractor struct{}
 
-func (nopReqInfoExtractor) PutRequestToInfo(*objectgrpc.PutRequest) (v2.RequestInfo, user.ID, error) {
+func (nopReqInfoExtractor) PutRequestToInfo(*protoobject.PutRequest) (v2.RequestInfo, user.ID, error) {
 	return v2.RequestInfo{}, user.ID{}, nil
 }
-func (nopReqInfoExtractor) DeleteRequestToInfo(*objectgrpc.DeleteRequest) (v2.RequestInfo, error) {
+func (nopReqInfoExtractor) DeleteRequestToInfo(*protoobject.DeleteRequest) (v2.RequestInfo, error) {
 	return v2.RequestInfo{}, nil
 }
-func (nopReqInfoExtractor) HeadRequestToInfo(*objectgrpc.HeadRequest) (v2.RequestInfo, error) {
+func (nopReqInfoExtractor) HeadRequestToInfo(*protoobject.HeadRequest) (v2.RequestInfo, error) {
 	return v2.RequestInfo{}, nil
 }
-func (nopReqInfoExtractor) HashRequestToInfo(*objectgrpc.GetRangeHashRequest) (v2.RequestInfo, error) {
+func (nopReqInfoExtractor) HashRequestToInfo(*protoobject.GetRangeHashRequest) (v2.RequestInfo, error) {
 	return v2.RequestInfo{}, nil
 }
-func (nopReqInfoExtractor) GetRequestToInfo(*objectgrpc.GetRequest) (v2.RequestInfo, error) {
+func (nopReqInfoExtractor) GetRequestToInfo(*protoobject.GetRequest) (v2.RequestInfo, error) {
 	return v2.RequestInfo{}, nil
 }
-func (nopReqInfoExtractor) RangeRequestToInfo(*objectgrpc.GetRangeRequest) (v2.RequestInfo, error) {
+func (nopReqInfoExtractor) RangeRequestToInfo(*protoobject.GetRangeRequest) (v2.RequestInfo, error) {
 	return v2.RequestInfo{}, nil
 }
-func (nopReqInfoExtractor) SearchRequestToInfo(*objectgrpc.SearchRequest) (v2.RequestInfo, error) {
+func (nopReqInfoExtractor) SearchRequestToInfo(*protoobject.SearchRequest) (v2.RequestInfo, error) {
 	return v2.RequestInfo{}, nil
 }
 
@@ -210,17 +209,17 @@ func (*testFSChain) LocalNodeUnderMaintenance() bool { return false }
 type testStorage struct {
 	t testing.TB
 	// request data
-	obj *objectgrpc.Object
+	obj *protoobject.Object
 	// return
 	storeErr error
 }
 
-func newTestStorage(t testing.TB, obj *objectgrpc.Object) *testStorage {
+func newTestStorage(t testing.TB, obj *protoobject.Object) *testStorage {
 	return &testStorage{t: t, obj: obj}
 }
 
 func (x *testStorage) VerifyAndStoreObjectLocally(obj object.Object) error {
-	require.Equal(x.t, x.obj, obj.ToV2().ToGRPCMessage().(*objectgrpc.Object))
+	require.Equal(x.t, x.obj, obj.ProtoMessage())
 	return x.storeErr
 }
 
@@ -228,7 +227,7 @@ func (x *testStorage) GetSessionPrivateKey(user.ID, uuid.UUID) (ecdsa.PrivateKey
 	return ecdsa.PrivateKey{}, apistatus.ErrSessionTokenNotFound
 }
 
-func anyValidRequest(tb testing.TB, signer neofscrypto.Signer, cnr cid.ID, objID oid.ID) (*objectgrpc.ReplicateRequest, object.Object) {
+func anyValidRequest(tb testing.TB, signer neofscrypto.Signer, cnr cid.ID, objID oid.ID) (*protoobject.ReplicateRequest, object.Object) {
 	obj := objecttest.Object()
 	obj.SetType(object.TypeRegular)
 	obj.SetContainerID(cnr)
@@ -239,8 +238,8 @@ func anyValidRequest(tb testing.TB, signer neofscrypto.Signer, cnr cid.ID, objID
 	sig, err := signer.Sign(objID[:])
 	require.NoError(tb, err)
 
-	req := &objectgrpc.ReplicateRequest{
-		Object: obj.ToV2().ToGRPCMessage().(*objectgrpc.Object),
+	req := &protoobject.ReplicateRequest{
+		Object: obj.ProtoMessage(),
 		Signature: &refs.Signature{
 			Key:  neofscrypto.PublicKeyBytes(signer.Public()),
 			Sign: sig,
@@ -420,8 +419,8 @@ func TestServer_Replicate(t *testing.T) {
 			obj := objecttest.Object()
 			bObj := obj.Marshal()
 
-			resp, err := noCallSrv.Replicate(context.Background(), &objectgrpc.ReplicateRequest{
-				Object:    obj.ToV2().ToGRPCMessage().(*objectgrpc.Object),
+			resp, err := noCallSrv.Replicate(context.Background(), &protoobject.ReplicateRequest{
+				Object:    obj.ProtoMessage(),
 				Signature: tc.fSig(bObj),
 			})
 			require.NoError(t, err, tc.name)
@@ -503,13 +502,10 @@ func TestServer_Replicate(t *testing.T) {
 			sigsRaw := resp.GetObjectSignature()
 
 			for i := range 3 {
-				var sigV2 refsv2.Signature
+				var sig neofscrypto.Signature
 				l := binary.LittleEndian.Uint32(sigsRaw)
 
-				require.NoError(t, sigV2.Unmarshal(sigsRaw[4:4+l]))
-
-				var sig neofscrypto.Signature
-				require.NoError(t, sig.ReadFromV2(sigV2))
+				require.NoError(t, sig.Unmarshal(sigsRaw[4:4+l]))
 
 				require.Equal(t, signer.PublicKeyBytes, sig.PublicKeyBytes())
 				require.True(t, sig.Verify(objectcore.EncodeReplicationMetaInfo(
diff --git a/pkg/services/object/util/key_test.go b/pkg/services/object/util/key_test.go
index cc41f5e741..00da1ace7b 100644
--- a/pkg/services/object/util/key_test.go
+++ b/pkg/services/object/util/key_test.go
@@ -5,8 +5,6 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	"github.com/nspcc-dev/neofs-api-go/v2/refs"
-	sessionV2 "github.com/nspcc-dev/neofs-api-go/v2/session"
 	"github.com/nspcc-dev/neofs-node/pkg/services/object/util"
 	tokenStorage "github.com/nspcc-dev/neofs-node/pkg/services/session/storage/temporary"
 	neofsecdsa "github.com/nspcc-dev/neofs-sdk-go/crypto/ecdsa"
@@ -62,13 +60,6 @@ func TestNewKeyStorage(t *testing.T) {
 }
 
 func createToken(t *testing.T, store *tokenStorage.TokenStore, owner user.ID, exp uint64) session.Object {
-	var ownerV2 refs.OwnerID
-	owner.WriteToV2(&ownerV2)
-
-	req := new(sessionV2.CreateRequestBody)
-	req.SetOwnerID(&ownerV2)
-	req.SetExpiration(exp)
-
 	key := neofscryptotest.ECDSAPrivateKey()
 	id := uuid.New()
 	err := store.Store(key, owner, id[:], exp)
diff --git a/pkg/services/object/util/prm.go b/pkg/services/object/util/prm.go
index 750aa9678a..9c47d416f3 100644
--- a/pkg/services/object/util/prm.go
+++ b/pkg/services/object/util/prm.go
@@ -3,10 +3,8 @@ package util
 import (
 	"fmt"
 
-	apiacl "github.com/nspcc-dev/neofs-api-go/v2/acl"
-	"github.com/nspcc-dev/neofs-api-go/v2/session"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	"github.com/nspcc-dev/neofs-sdk-go/bearer"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
 	sessionsdk "github.com/nspcc-dev/neofs-sdk-go/session"
 )
 
@@ -97,30 +95,22 @@ func CommonPrmFromRequest(req interface {
 	}
 
 	var st *sessionsdk.Object
-	if mt := meta.GetSessionToken(); mt != nil {
-		var st2 session.Token
-		if err := st2.FromGRPCMessage(mt); err != nil {
-			panic(err)
-		}
+	if meta.SessionToken != nil {
 		st = new(sessionsdk.Object)
-		if err := st.ReadFromV2(st2); err != nil {
+		if err := st.FromProtoMessage(meta.SessionToken); err != nil {
 			return nil, fmt.Errorf("invalid session token: %w", err)
 		}
 	}
 
 	var bt *bearer.Token
-	if mt := meta.GetBearerToken(); mt != nil {
-		var bt2 apiacl.BearerToken
-		if err := bt2.FromGRPCMessage(mt); err != nil {
-			panic(err)
-		}
+	if meta.BearerToken != nil {
 		bt = new(bearer.Token)
-		if err := bt.ReadFromV2(bt2); err != nil {
+		if err := bt.FromProtoMessage(meta.BearerToken); err != nil {
 			return nil, fmt.Errorf("invalid bearer token: %w", err)
 		}
 	}
 
-	xHdrs := meta.GetXHeaders()
+	xHdrs := meta.XHeaders
 	prm := &CommonPrm{
 		local:  ttl <= maxLocalTTL,
 		token:  st,
diff --git a/pkg/services/session/server.go b/pkg/services/session/server.go
index f375f62cff..8ee10c01de 100644
--- a/pkg/services/session/server.go
+++ b/pkg/services/session/server.go
@@ -9,16 +9,12 @@ import (
 	"fmt"
 
 	"github.com/google/uuid"
-	apirefs "github.com/nspcc-dev/neofs-api-go/v2/refs"
-	refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	apisession "github.com/nspcc-dev/neofs-api-go/v2/session"
-	protosession "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/services/util"
 	neofscrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
 	neofsecdsa "github.com/nspcc-dev/neofs-sdk-go/crypto/ecdsa"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
 )
@@ -50,18 +46,16 @@ func New(s *ecdsa.PrivateKey, net netmap.State, ks KeyStorage) protosession.Sess
 }
 
 func (s *server) makeCreateResponse(body *protosession.CreateResponse_Body, st *protostatus.Status) (*protosession.CreateResponse, error) {
-	v := version.Current()
-	var v2 apirefs.Version
-	v.WriteToV2(&v2)
 	resp := &protosession.CreateResponse{
 		Body: body,
 		MetaHeader: &protosession.ResponseMetaHeader{
-			Version: v2.ToGRPCMessage().(*refs.Version),
+			Version: version.Current().ProtoMessage(),
 			Epoch:   s.net.CurrentEpoch(),
 			Status:  st,
 		},
 	}
-	return util.SignResponse(s.signer, resp, apisession.CreateResponse{}), nil
+	resp.VerifyHeader = util.SignResponse(s.signer, resp)
+	return resp, nil
 }
 
 func (s *server) makeFailedCreateResponse(err error) (*protosession.CreateResponse, error) {
@@ -71,11 +65,7 @@ func (s *server) makeFailedCreateResponse(err error) (*protosession.CreateRespon
 // Create generates new private session key and saves it in the underlying
 // [KeyStorage].
 func (s *server) Create(_ context.Context, req *protosession.CreateRequest) (*protosession.CreateResponse, error) {
-	createReq := new(apisession.CreateRequest)
-	if err := createReq.FromGRPCMessage(req); err != nil {
-		return nil, err
-	}
-	if err := signature.VerifyServiceMessage(createReq); err != nil {
+	if err := neofscrypto.VerifyRequestWithBuffer(req, nil); err != nil {
 		return s.makeFailedCreateResponse(err)
 	}
 
@@ -84,12 +74,8 @@ func (s *server) Create(_ context.Context, req *protosession.CreateRequest) (*pr
 	if mUsr == nil {
 		return s.makeFailedCreateResponse(errors.New("missing account"))
 	}
-	var usr2 apirefs.OwnerID
-	if err := usr2.FromGRPCMessage(mUsr); err != nil {
-		panic(err)
-	}
 	var usr user.ID
-	if err := usr.ReadFromV2(usr2); err != nil {
+	if err := usr.FromProtoMessage(mUsr); err != nil {
 		return s.makeFailedCreateResponse(fmt.Errorf("invalid account: %w", err))
 	}
 
diff --git a/pkg/services/tree/signature_test.go b/pkg/services/tree/signature_test.go
index cf51d92839..47409be92b 100644
--- a/pkg/services/tree/signature_test.go
+++ b/pkg/services/tree/signature_test.go
@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	aclV2 "github.com/nspcc-dev/neofs-api-go/v2/acl"
 	containercore "github.com/nspcc-dev/neofs-node/pkg/core/container"
 	"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-sdk-go/bearer"
@@ -164,10 +163,11 @@ func TestMessageSign(t *testing.T) {
 			bt := testBearerToken(cid1, privs[1].PublicKey(), privs[2].PublicKey())
 			require.NoError(t, bt.Sign(signer))
 
-			var bv2 aclV2.BearerToken
-			bt.WriteToV2(&bv2)
-			bv2.GetSignature().SetSign([]byte{1, 2, 3})
-			req.Body.BearerToken = bv2.StableMarshal(nil)
+			pacl := bt.ProtoMessage()
+			pacl.Signature.Sign = []byte{1, 2, 3}
+			b := make([]byte, pacl.MarshaledSize())
+			pacl.MarshalStable(b)
+			req.Body.BearerToken = b
 
 			require.NoError(t, SignMessage(req, &privs[1].PrivateKey))
 			require.Error(t, s.verifyClient(req, cid1, req.GetBody().GetBearerToken(), acl.OpObjectPut))
diff --git a/pkg/services/util/sign.go b/pkg/services/util/sign.go
index a25c04ed23..fef6b5443b 100644
--- a/pkg/services/util/sign.go
+++ b/pkg/services/util/sign.go
@@ -4,28 +4,21 @@ import (
 	"crypto/ecdsa"
 	"errors"
 
-	"github.com/nspcc-dev/neofs-api-go/v2/rpc/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/signature"
-	protostatus "github.com/nspcc-dev/neofs-api-go/v2/status/grpc"
 	apistatus "github.com/nspcc-dev/neofs-sdk-go/client/status"
-	"google.golang.org/protobuf/proto"
+	sdkcrypto "github.com/nspcc-dev/neofs-sdk-go/crypto"
+	sdkecdsa "github.com/nspcc-dev/neofs-sdk-go/crypto/ecdsa"
+	protosession "github.com/nspcc-dev/neofs-sdk-go/proto/session"
+	protostatus "github.com/nspcc-dev/neofs-sdk-go/proto/status"
 )
 
-func SignResponse[R proto.Message, RV2 any, RV2PTR interface {
-	*RV2
-	ToGRPCMessage() grpc.Message
-	FromGRPCMessage(message grpc.Message) error
-}](signer *ecdsa.PrivateKey, r R, _ RV2) R {
-	r2 := RV2PTR(new(RV2))
-	if err := r2.FromGRPCMessage(r); err != nil {
-		panic(err) // can only fail on wrong type, here it's correct
-	}
-	if err := signature.SignServiceMessage(signer, r2); err != nil {
+func SignResponse[R sdkcrypto.ProtoMessage](signer *ecdsa.PrivateKey, r sdkcrypto.SignedResponse[R]) *protosession.ResponseVerificationHeader {
+	verHeader, err := sdkcrypto.SignResponseWithBuffer(sdkecdsa.Signer(*signer), r, nil)
+	if err != nil {
 		// We can't pass this error as NeoFS status code since response will be unsigned.
 		// Isn't expected in practice, so panic is ok here.
 		panic(err)
 	}
-	return r2.ToGRPCMessage().(R)
+	return verHeader
 }
 
 var (
@@ -44,7 +37,7 @@ func ToStatus(err error) *protostatus.Status {
 	for e := errors.Unwrap(err); e != nil; e = errors.Unwrap(err) {
 		err = e
 	}
-	return apistatus.ErrorToV2(err).ToGRPCMessage().(*protostatus.Status)
+	return apistatus.FromError(err)
 }
 
 // ToRequestSignatureVerificationError constructs status error describing