diff --git a/v2/accounting/grpc/service.pb.go b/v2/accounting/grpc/service.pb.go
index af398bb..34d15ac 100644
--- a/v2/accounting/grpc/service.pb.go
+++ b/v2/accounting/grpc/service.pb.go
@@ -8,7 +8,7 @@ import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
+	grpc "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	grpc2 "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -285,35 +285,35 @@ func init() {
 func init() { proto.RegisterFile("v2/accounting/grpc/service.proto", fileDescriptor_d9dd5af2ff2bbb25) }
 
 var fileDescriptor_d9dd5af2ff2bbb25 = []byte{
-	// 438 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcb, 0x8a, 0xd4, 0x40,
-	0x18, 0x85, 0x4d, 0x1c, 0x6c, 0xa9, 0xf1, 0x82, 0x85, 0x30, 0x4d, 0xc4, 0x30, 0x0c, 0x33, 0xa0,
-	0x62, 0x2a, 0x10, 0x17, 0x82, 0xa2, 0xc3, 0x34, 0xe3, 0x60, 0x2f, 0xbc, 0x65, 0x60, 0x16, 0x6e,
-	0x86, 0x4a, 0xe5, 0x4f, 0xa6, 0xe8, 0x4e, 0x55, 0x4c, 0x55, 0x47, 0xf2, 0x26, 0xbe, 0x80, 0x1b,
-	0x17, 0x3e, 0x87, 0x4b, 0x1f, 0x41, 0xda, 0x17, 0x91, 0xdc, 0xfa, 0x42, 0xa7, 0xed, 0xde, 0xa5,
-	0xf8, 0xcf, 0x39, 0x7f, 0x9d, 0x8f, 0x14, 0xda, 0xcf, 0x3d, 0x97, 0x32, 0x26, 0x27, 0x42, 0x73,
-	0x11, 0xbb, 0x71, 0x96, 0x32, 0x57, 0x41, 0x96, 0x73, 0x06, 0x24, 0xcd, 0xa4, 0x96, 0xf8, 0xbe,
-	0x00, 0x49, 0x22, 0x45, 0x72, 0x8f, 0xcc, 0x85, 0x96, 0xdd, 0xe1, 0xd3, 0x45, 0x0a, 0xaa, 0x76,
-	0x59, 0xfd, 0xdc, 0x73, 0x33, 0x88, 0xd4, 0xea, 0xe4, 0x41, 0xee, 0xb5, 0x1b, 0x56, 0x86, 0x07,
-	0xdf, 0x4d, 0x74, 0x67, 0x40, 0xc7, 0x54, 0x30, 0xf0, 0xe1, 0xcb, 0x04, 0x94, 0xc6, 0xaf, 0xd0,
-	0x4e, 0x20, 0xc3, 0xa2, 0x6f, 0xec, 0x1b, 0x8f, 0x76, 0xbd, 0xc7, 0xa4, 0xeb, 0x3a, 0x64, 0xd9,
-	0x43, 0x06, 0x32, 0x2c, 0xfc, 0xca, 0x86, 0xdf, 0xa0, 0xdd, 0x04, 0x34, 0xbd, 0xbc, 0x02, 0x1a,
-	0x42, 0xd6, 0x37, 0xab, 0x94, 0xc3, 0x85, 0x94, 0xb6, 0x6d, 0xe3, 0x7d, 0x07, 0x9a, 0xbe, 0xad,
-	0xb4, 0x3e, 0x4a, 0x66, 0xdf, 0xf8, 0x13, 0xba, 0x9d, 0x43, 0xc6, 0xa3, 0xa2, 0x0d, 0xba, 0x5e,
-	0x05, 0x3d, 0x5d, 0x1f, 0x74, 0x51, 0xca, 0x39, 0xa3, 0x9a, 0x4b, 0xd1, 0x04, 0xde, 0xaa, 0x23,
-	0xea, 0x93, 0xf5, 0x02, 0xed, 0x94, 0xf7, 0xc4, 0x1e, 0xba, 0x29, 0xbf, 0x0a, 0xc8, 0x2e, 0x79,
-	0xd8, 0x94, 0xdc, 0x5b, 0x48, 0x2d, 0x21, 0x92, 0x0f, 0xe5, 0x7c, 0x78, 0xea, 0xf7, 0x2a, 0xe1,
-	0x30, 0x3c, 0xf8, 0x69, 0xa2, 0xbb, 0xb3, 0xce, 0x2a, 0x95, 0x42, 0x01, 0x7e, 0xbd, 0x04, 0xea,
-	0xc9, 0x06, 0x50, 0xb5, 0x69, 0x91, 0xd4, 0x59, 0x17, 0xa9, 0xa3, 0xce, 0x82, 0xb5, 0x79, 0x0d,
-	0x2a, 0xbf, 0x1b, 0x95, 0xf3, 0x9f, 0xa4, 0x8d, 0xac, 0x8e, 0x1b, 0x56, 0xcf, 0x51, 0x2f, 0xa8,
-	0x1b, 0x34, 0x35, 0x1f, 0x76, 0xd7, 0x3c, 0x05, 0xc6, 0x13, 0x3a, 0xf6, 0x5b, 0xb5, 0x37, 0x42,
-	0xf7, 0x4e, 0x66, 0xe3, 0xf3, 0x7a, 0x3d, 0xbe, 0x40, 0xbd, 0x86, 0x07, 0x3e, 0xdc, 0xe6, 0xbf,
-	0xb2, 0x8e, 0xb6, 0x82, 0x3a, 0x18, 0xfd, 0x9a, 0xda, 0xc6, 0xef, 0xa9, 0x6d, 0xfc, 0x99, 0xda,
-	0xc6, 0xb7, 0xbf, 0xf6, 0xb5, 0xcf, 0xc7, 0x31, 0xd7, 0x57, 0x93, 0x80, 0x30, 0x99, 0xb8, 0x42,
-	0xa5, 0x8c, 0x39, 0x21, 0xe4, 0xae, 0x00, 0x19, 0x29, 0x87, 0xa6, 0xdc, 0x89, 0xa5, 0xbb, 0xfa,
-	0xa0, 0x5e, 0xce, 0xcf, 0x3f, 0xcc, 0xbd, 0xf7, 0x20, 0xcf, 0xce, 0xc9, 0xc9, 0xc7, 0x61, 0xb9,
-	0x7c, 0xde, 0x25, 0xb8, 0x51, 0xbd, 0x9c, 0x67, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x15, 0x3d,
-	0x57, 0xcb, 0xca, 0x03, 0x00, 0x00,
+	// 442 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xdb, 0x6a, 0xd4, 0x40,
+	0x1c, 0xc6, 0x4d, 0x2c, 0xae, 0x4c, 0x3d, 0xe0, 0x20, 0x74, 0x89, 0x18, 0x4a, 0x69, 0x41, 0xc5,
+	0xcc, 0x40, 0xbc, 0x10, 0x14, 0x2d, 0x5d, 0x6a, 0x71, 0x2f, 0x3c, 0xa5, 0xd0, 0x0b, 0x6f, 0xca,
+	0x64, 0xf2, 0x4f, 0x3a, 0xb4, 0x99, 0x89, 0x99, 0xd9, 0x48, 0xde, 0xc4, 0x17, 0xf0, 0xc6, 0x0b,
+	0x9f, 0xc3, 0x4b, 0x1f, 0x41, 0xd6, 0x17, 0x91, 0x1c, 0xf6, 0xc4, 0x66, 0xdd, 0xbd, 0xcb, 0xf0,
+	0xff, 0xbe, 0x2f, 0xff, 0xef, 0xc7, 0x0c, 0xda, 0x2d, 0x7c, 0xca, 0x38, 0x57, 0x23, 0x69, 0x84,
+	0x4c, 0x68, 0x92, 0x67, 0x9c, 0x6a, 0xc8, 0x0b, 0xc1, 0x81, 0x64, 0xb9, 0x32, 0x0a, 0xdf, 0x97,
+	0xa0, 0x48, 0xac, 0x49, 0xe1, 0x93, 0x99, 0xd0, 0x71, 0x3b, 0x7c, 0xa6, 0xcc, 0x40, 0x37, 0x2e,
+	0xa7, 0x5f, 0xf8, 0x34, 0x87, 0x58, 0x2f, 0x4f, 0x1e, 0x14, 0x3e, 0xd5, 0xa0, 0xb5, 0x50, 0x72,
+	0x69, 0xb8, 0xf7, 0xdd, 0x46, 0x77, 0x06, 0xec, 0x8a, 0x49, 0x0e, 0x01, 0x7c, 0x19, 0x81, 0x36,
+	0xf8, 0x15, 0xda, 0x0a, 0x55, 0x54, 0xf6, 0xad, 0x5d, 0xeb, 0xd1, 0xb6, 0xff, 0x98, 0x74, 0xad,
+	0x43, 0x16, 0x3d, 0x64, 0xa0, 0xa2, 0x32, 0xa8, 0x6d, 0xf8, 0x0d, 0xda, 0x4e, 0xc1, 0xb0, 0xf3,
+	0x0b, 0x60, 0x11, 0xe4, 0x7d, 0xbb, 0x4e, 0xd9, 0x9f, 0x4b, 0x69, 0x77, 0x21, 0xad, 0xf7, 0x1d,
+	0x18, 0xf6, 0xb6, 0xd6, 0x06, 0x28, 0x9d, 0x7e, 0xe3, 0x4f, 0xe8, 0x76, 0x01, 0xb9, 0x88, 0xcb,
+	0x49, 0xd0, 0xf5, 0x3a, 0xe8, 0xe9, 0xea, 0xa0, 0xb3, 0x4a, 0x2e, 0x38, 0x33, 0x42, 0xc9, 0x36,
+	0xf0, 0x56, 0x13, 0xd1, 0x9c, 0x9c, 0x17, 0x68, 0xab, 0xda, 0x13, 0xfb, 0xe8, 0xa6, 0xfa, 0x2a,
+	0x21, 0x3f, 0x17, 0x51, 0x5b, 0x72, 0x67, 0x2e, 0xb5, 0x82, 0x48, 0x3e, 0x54, 0xf3, 0xe1, 0x71,
+	0xd0, 0xab, 0x85, 0xc3, 0x68, 0xef, 0xa7, 0x8d, 0xee, 0x4e, 0x3b, 0xeb, 0x4c, 0x49, 0x0d, 0xf8,
+	0xf5, 0x02, 0xa8, 0x27, 0x6b, 0x40, 0x35, 0xa6, 0x79, 0x52, 0x27, 0x5d, 0xa4, 0x0e, 0x3a, 0x0b,
+	0x36, 0xe6, 0x15, 0xa8, 0x82, 0x6e, 0x54, 0xde, 0x7f, 0x92, 0xd6, 0xb2, 0x3a, 0x6c, 0x59, 0x3d,
+	0x47, 0xbd, 0xb0, 0x69, 0xd0, 0xd6, 0x7c, 0xd8, 0x5d, 0xf3, 0x18, 0xb8, 0x48, 0xd9, 0x55, 0x30,
+	0x51, 0xfb, 0x97, 0xe8, 0xde, 0xd1, 0x74, 0x7c, 0xda, 0x5c, 0x70, 0x7c, 0x86, 0x7a, 0x2d, 0x0f,
+	0xbc, 0xbf, 0xc9, 0xbd, 0x72, 0x0e, 0x36, 0x82, 0x3a, 0xb8, 0xfc, 0x35, 0x76, 0xad, 0xdf, 0x63,
+	0xd7, 0xfa, 0x33, 0x76, 0xad, 0x6f, 0x7f, 0xdd, 0x6b, 0x9f, 0x0f, 0x13, 0x61, 0x2e, 0x46, 0x21,
+	0xe1, 0x2a, 0xa5, 0x52, 0x67, 0x9c, 0x7b, 0x11, 0x14, 0x54, 0x82, 0x8a, 0xb5, 0xc7, 0x32, 0xe1,
+	0x25, 0x8a, 0x2e, 0x3f, 0xa8, 0x97, 0xb3, 0xf3, 0x0f, 0x7b, 0xe7, 0x3d, 0xa8, 0x93, 0x53, 0x72,
+	0xf4, 0x71, 0x58, 0xfd, 0x7c, 0xd6, 0x25, 0xbc, 0x51, 0xbf, 0x9c, 0x67, 0xff, 0x02, 0x00, 0x00,
+	0xff, 0xff, 0x54, 0x53, 0x6d, 0x41, 0xca, 0x03, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/v2/acl/grpc/types.pb.go b/v2/acl/grpc/types.pb.go
index e9932c8..7c240bd 100644
--- a/v2/acl/grpc/types.pb.go
+++ b/v2/acl/grpc/types.pb.go
@@ -477,6 +477,198 @@ func (m *EACLTable) GetRecords() []*EACLRecord {
 	return nil
 }
 
+// BearerToken has information about request ACL rules with limited lifetime
+type BearerToken struct {
+	// Bearer Token body
+	Body *BearerToken_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
+	// Signature of BearerToken body
+	Signature            *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *BearerToken) Reset()         { *m = BearerToken{} }
+func (m *BearerToken) String() string { return proto.CompactTextString(m) }
+func (*BearerToken) ProtoMessage()    {}
+func (*BearerToken) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8233b6696fb3e24f, []int{2}
+}
+func (m *BearerToken) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BearerToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BearerToken.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *BearerToken) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BearerToken.Merge(m, src)
+}
+func (m *BearerToken) XXX_Size() int {
+	return m.Size()
+}
+func (m *BearerToken) XXX_DiscardUnknown() {
+	xxx_messageInfo_BearerToken.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BearerToken proto.InternalMessageInfo
+
+func (m *BearerToken) GetBody() *BearerToken_Body {
+	if m != nil {
+		return m.Body
+	}
+	return nil
+}
+
+func (m *BearerToken) GetSignature() *grpc.Signature {
+	if m != nil {
+		return m.Signature
+	}
+	return nil
+}
+
+// Bearer Token body
+type BearerToken_Body struct {
+	// EACLTable carries table of extended ACL rules
+	EaclTable *EACLTable `protobuf:"bytes,1,opt,name=eacl_table,json=eaclTable,proto3" json:"eacl_table,omitempty"`
+	// OwnerID carries identifier of the token owner
+	OwnerId *grpc.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
+	// Token expiration and valid time period parameters
+	Lifetime             *BearerToken_Body_TokenLifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
+	XXX_unrecognized     []byte                          `json:"-"`
+	XXX_sizecache        int32                           `json:"-"`
+}
+
+func (m *BearerToken_Body) Reset()         { *m = BearerToken_Body{} }
+func (m *BearerToken_Body) String() string { return proto.CompactTextString(m) }
+func (*BearerToken_Body) ProtoMessage()    {}
+func (*BearerToken_Body) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8233b6696fb3e24f, []int{2, 0}
+}
+func (m *BearerToken_Body) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BearerToken_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BearerToken_Body.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *BearerToken_Body) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BearerToken_Body.Merge(m, src)
+}
+func (m *BearerToken_Body) XXX_Size() int {
+	return m.Size()
+}
+func (m *BearerToken_Body) XXX_DiscardUnknown() {
+	xxx_messageInfo_BearerToken_Body.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BearerToken_Body proto.InternalMessageInfo
+
+func (m *BearerToken_Body) GetEaclTable() *EACLTable {
+	if m != nil {
+		return m.EaclTable
+	}
+	return nil
+}
+
+func (m *BearerToken_Body) GetOwnerId() *grpc.OwnerID {
+	if m != nil {
+		return m.OwnerId
+	}
+	return nil
+}
+
+func (m *BearerToken_Body) GetLifetime() *BearerToken_Body_TokenLifetime {
+	if m != nil {
+		return m.Lifetime
+	}
+	return nil
+}
+
+// Lifetime parameters of the token. Filed names taken from rfc7519.
+type BearerToken_Body_TokenLifetime struct {
+	// Expiration Epoch
+	Exp uint64 `protobuf:"varint,1,opt,name=exp,proto3" json:"exp,omitempty"`
+	// Not valid before Epoch
+	Nbf uint64 `protobuf:"varint,2,opt,name=nbf,proto3" json:"nbf,omitempty"`
+	// Issued at Epoch
+	Iat                  uint64   `protobuf:"varint,3,opt,name=iat,proto3" json:"iat,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BearerToken_Body_TokenLifetime) Reset()         { *m = BearerToken_Body_TokenLifetime{} }
+func (m *BearerToken_Body_TokenLifetime) String() string { return proto.CompactTextString(m) }
+func (*BearerToken_Body_TokenLifetime) ProtoMessage()    {}
+func (*BearerToken_Body_TokenLifetime) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8233b6696fb3e24f, []int{2, 0, 0}
+}
+func (m *BearerToken_Body_TokenLifetime) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BearerToken_Body_TokenLifetime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BearerToken_Body_TokenLifetime.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *BearerToken_Body_TokenLifetime) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BearerToken_Body_TokenLifetime.Merge(m, src)
+}
+func (m *BearerToken_Body_TokenLifetime) XXX_Size() int {
+	return m.Size()
+}
+func (m *BearerToken_Body_TokenLifetime) XXX_DiscardUnknown() {
+	xxx_messageInfo_BearerToken_Body_TokenLifetime.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BearerToken_Body_TokenLifetime proto.InternalMessageInfo
+
+func (m *BearerToken_Body_TokenLifetime) GetExp() uint64 {
+	if m != nil {
+		return m.Exp
+	}
+	return 0
+}
+
+func (m *BearerToken_Body_TokenLifetime) GetNbf() uint64 {
+	if m != nil {
+		return m.Nbf
+	}
+	return 0
+}
+
+func (m *BearerToken_Body_TokenLifetime) GetIat() uint64 {
+	if m != nil {
+		return m.Iat
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterEnum("neo.fs.v2.acl.Target", Target_name, Target_value)
 	proto.RegisterEnum("neo.fs.v2.acl.MatchType", MatchType_name, MatchType_value)
@@ -487,56 +679,69 @@ func init() {
 	proto.RegisterType((*EACLRecord_FilterInfo)(nil), "neo.fs.v2.acl.EACLRecord.FilterInfo")
 	proto.RegisterType((*EACLRecord_TargetInfo)(nil), "neo.fs.v2.acl.EACLRecord.TargetInfo")
 	proto.RegisterType((*EACLTable)(nil), "neo.fs.v2.acl.EACLTable")
+	proto.RegisterType((*BearerToken)(nil), "neo.fs.v2.acl.BearerToken")
+	proto.RegisterType((*BearerToken_Body)(nil), "neo.fs.v2.acl.BearerToken.Body")
+	proto.RegisterType((*BearerToken_Body_TokenLifetime)(nil), "neo.fs.v2.acl.BearerToken.Body.TokenLifetime")
 }
 
 func init() { proto.RegisterFile("v2/acl/grpc/types.proto", fileDescriptor_8233b6696fb3e24f) }
 
 var fileDescriptor_8233b6696fb3e24f = []byte{
-	// 703 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x54, 0xd1, 0x6e, 0xda, 0x48,
-	0x14, 0x8d, 0x6d, 0x62, 0xc2, 0x85, 0x5d, 0x8d, 0x46, 0x1b, 0xd6, 0x61, 0x25, 0x84, 0xa2, 0x7d,
-	0x40, 0xac, 0x30, 0x5a, 0xa2, 0xec, 0x3e, 0x54, 0x8d, 0xe4, 0xc0, 0x04, 0x68, 0x89, 0x4d, 0xc6,
-	0x43, 0xaa, 0xf4, 0x05, 0x39, 0x66, 0x20, 0xa8, 0xc6, 0x46, 0xb6, 0x83, 0x44, 0x9f, 0xfa, 0x19,
-	0xfd, 0x86, 0x3e, 0xf6, 0x2b, 0xfa, 0xd8, 0x4f, 0xa8, 0xd2, 0xcf, 0xe8, 0x4b, 0x65, 0x1b, 0x02,
-	0x75, 0x2a, 0xf5, 0xc9, 0xd7, 0x73, 0xcf, 0x39, 0xf7, 0xcc, 0xf1, 0x78, 0xe0, 0xcf, 0x65, 0xb3,
-	0x61, 0xd9, 0x4e, 0x63, 0xea, 0x2f, 0xec, 0x46, 0xb8, 0x5a, 0xf0, 0x40, 0x5d, 0xf8, 0x5e, 0xe8,
-	0xe1, 0xdf, 0x5c, 0xee, 0xa9, 0x93, 0x40, 0x5d, 0x36, 0x55, 0xcb, 0x76, 0x4a, 0xca, 0xb2, 0xd9,
-	0xf0, 0xf9, 0x24, 0x78, 0x02, 0x3c, 0xfe, 0x26, 0x01, 0x10, 0xad, 0xd5, 0xa7, 0xdc, 0xf6, 0xfc,
-	0x31, 0xfe, 0x0f, 0x72, 0xde, 0x82, 0xfb, 0x56, 0x38, 0xf3, 0x5c, 0x45, 0xa8, 0x08, 0xd5, 0xdf,
-	0x9b, 0x8a, 0xfa, 0x83, 0x96, 0x6a, 0x6c, 0xfa, 0x34, 0xf7, 0x58, 0xe2, 0x3a, 0xc8, 0x96, 0x1d,
-	0x93, 0xc4, 0x98, 0x74, 0x98, 0x22, 0x69, 0x71, 0x93, 0xca, 0xc9, 0x13, 0x9f, 0x41, 0x76, 0x32,
-	0x73, 0x42, 0xee, 0x07, 0x8a, 0x54, 0x91, 0xaa, 0xf9, 0xe6, 0xdf, 0x29, 0xfc, 0xd6, 0x92, 0x7a,
-	0x11, 0x03, 0x7b, 0xee, 0xc4, 0xa3, 0xd9, 0xa4, 0x0e, 0x22, 0x7e, 0x68, 0xf9, 0x53, 0x1e, 0x06,
-	0x4a, 0xe6, 0x57, 0x7c, 0x16, 0x03, 0x13, 0x7e, 0x52, 0x07, 0xa5, 0x8f, 0x02, 0xc0, 0x56, 0x17,
-	0x9f, 0x82, 0x7c, 0xc7, 0xad, 0x31, 0xf7, 0xd7, 0x5b, 0x3e, 0x4a, 0xa9, 0x75, 0xe3, 0x26, 0x5b,
-	0x2d, 0x38, 0x85, 0x6d, 0x8d, 0xff, 0x07, 0x98, 0x5b, 0xa1, 0x7d, 0x37, 0x8a, 0x02, 0x5d, 0x6f,
-	0x3c, 0x9d, 0xd6, 0x65, 0x04, 0x88, 0x99, 0xb9, 0xc7, 0x12, 0x1f, 0x41, 0x3e, 0x99, 0x37, 0x72,
-	0xad, 0x39, 0x57, 0xa4, 0x8a, 0x50, 0xcd, 0xd1, 0x8c, 0x6e, 0xcd, 0xa3, 0x16, 0xac, 0x5b, 0x4b,
-	0xcb, 0x51, 0x32, 0x71, 0x67, 0xff, 0xda, 0x72, 0xee, 0x79, 0xe9, 0x0a, 0x60, 0xbb, 0x17, 0xfc,
-	0x0f, 0xc8, 0x49, 0x04, 0x6b, 0xcf, 0xe9, 0xc4, 0x13, 0x28, 0xcd, 0x50, 0xcf, 0xe1, 0xb8, 0x08,
-	0x07, 0x6f, 0xf8, 0x6a, 0xe4, 0xcc, 0x82, 0x50, 0x11, 0x2b, 0x52, 0xb5, 0x40, 0x33, 0x2f, 0xf9,
-	0x2a, 0x38, 0x7e, 0x27, 0x40, 0x2e, 0x8a, 0x8a, 0x59, 0xb7, 0x0e, 0xc7, 0x67, 0x50, 0xb0, 0x3d,
-	0x37, 0xb4, 0x66, 0x2e, 0xf7, 0x47, 0xb3, 0x71, 0x2c, 0x9c, 0x6f, 0xfe, 0xb5, 0x23, 0x1c, 0x9d,
-	0x21, 0xb5, 0xb5, 0xc1, 0xf4, 0xda, 0x34, 0xbf, 0xf3, 0x82, 0x4f, 0x20, 0xeb, 0xc7, 0x99, 0x07,
-	0xf1, 0x90, 0xfc, 0x93, 0x1c, 0xb7, 0x5f, 0x85, 0x66, 0x93, 0x67, 0x50, 0x3b, 0x07, 0x39, 0xb1,
-	0x8a, 0x8b, 0x80, 0x99, 0x46, 0x3b, 0x84, 0x8d, 0x86, 0xba, 0x39, 0x20, 0xad, 0xde, 0x45, 0x8f,
-	0xb4, 0xd1, 0x1e, 0x3e, 0x80, 0xcc, 0xd0, 0x24, 0x14, 0x09, 0x18, 0x40, 0x36, 0x6f, 0x4c, 0x46,
-	0x2e, 0x91, 0x18, 0xd5, 0x06, 0xeb, 0x12, 0x6a, 0x22, 0xa9, 0x66, 0xc0, 0x4e, 0xb8, 0x25, 0x28,
-	0x5e, 0x6a, 0xac, 0xd5, 0x1d, 0xb1, 0x9b, 0x01, 0x49, 0x49, 0x21, 0x28, 0x98, 0x8c, 0xf6, 0xf4,
-	0xce, 0x88, 0x5c, 0x0d, 0xb5, 0x3e, 0x12, 0xf0, 0x1f, 0x80, 0xd6, 0x2b, 0xba, 0xc1, 0xd6, 0xab,
-	0x62, 0xed, 0x2d, 0xec, 0x9c, 0xed, 0x23, 0x38, 0x34, 0x06, 0x84, 0x6a, 0xac, 0x67, 0xe8, 0x29,
-	0xbd, 0x2c, 0x48, 0x1d, 0xc2, 0x90, 0x10, 0x79, 0xec, 0x12, 0xad, 0x8d, 0xc4, 0x68, 0x69, 0x30,
-	0x64, 0x48, 0x8a, 0x0c, 0xb6, 0x49, 0x9f, 0x30, 0x82, 0x32, 0xb1, 0x71, 0xa2, 0xd1, 0x56, 0x17,
-	0xed, 0xe3, 0x02, 0x1c, 0x74, 0x08, 0xa3, 0x9a, 0xde, 0x21, 0x48, 0x8e, 0x1c, 0x6d, 0xde, 0xba,
-	0x9a, 0xd9, 0x45, 0xd9, 0xda, 0x29, 0x6c, 0xfe, 0x92, 0x22, 0x60, 0xad, 0xf5, 0x93, 0xa9, 0x39,
-	0xd8, 0xd7, 0xfa, 0x7d, 0xe3, 0x55, 0x32, 0xb7, 0x4d, 0xf4, 0x1b, 0x24, 0xd6, 0x9e, 0xc3, 0xee,
-	0xd1, 0x2c, 0x02, 0x8e, 0xfc, 0x10, 0x9a, 0xa2, 0xe6, 0x21, 0x4b, 0xc9, 0xd5, 0x90, 0x98, 0x2c,
-	0x89, 0xd3, 0x38, 0x7f, 0x41, 0x5a, 0x0c, 0x89, 0xe7, 0xd7, 0x9f, 0x1e, 0xca, 0xc2, 0xe7, 0x87,
-	0xb2, 0xf0, 0xe5, 0xa1, 0x2c, 0xbc, 0xff, 0x5a, 0xde, 0x7b, 0xfd, 0xef, 0x74, 0x16, 0xde, 0xdd,
-	0xdf, 0xaa, 0xb6, 0x37, 0x6f, 0xb8, 0xc1, 0xc2, 0xb6, 0xeb, 0x63, 0xbe, 0x6c, 0xb8, 0xdc, 0x9b,
-	0x04, 0x75, 0x6b, 0x31, 0xab, 0x4f, 0xbd, 0xc6, 0xce, 0xed, 0xf3, 0xcc, 0xb2, 0x9d, 0x0f, 0x22,
-	0xd2, 0xb9, 0x77, 0x61, 0xaa, 0xda, 0xa0, 0x17, 0x7d, 0x72, 0xcd, 0x76, 0x6e, 0xe5, 0xf8, 0x9a,
-	0x39, 0xf9, 0x1e, 0x00, 0x00, 0xff, 0xff, 0xef, 0xd5, 0x9b, 0x33, 0xaa, 0x04, 0x00, 0x00,
+	// 862 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xdd, 0x6e, 0xe2, 0x46,
+	0x18, 0x5d, 0x63, 0x87, 0x9f, 0x8f, 0x6c, 0x65, 0x8d, 0xba, 0x2c, 0xa1, 0x52, 0x1a, 0x45, 0xbd,
+	0x88, 0xa8, 0x30, 0x2a, 0xd1, 0x76, 0x2f, 0xaa, 0xae, 0x64, 0x60, 0x02, 0xb4, 0x04, 0x93, 0xf1,
+	0xb0, 0x55, 0x7a, 0x83, 0x06, 0x33, 0x10, 0x6b, 0x1d, 0x1b, 0xd9, 0x0e, 0x5b, 0x7a, 0x55, 0xa9,
+	0xea, 0x3b, 0xf4, 0x19, 0x7a, 0xd9, 0xa7, 0xe8, 0x65, 0x1f, 0xa1, 0x4a, 0x1f, 0xa3, 0x37, 0xd5,
+	0x8c, 0x4d, 0x20, 0xde, 0x95, 0x72, 0xc5, 0xe7, 0xf9, 0xce, 0xf9, 0xce, 0x99, 0x33, 0xa3, 0x01,
+	0x5e, 0xae, 0x5b, 0x4d, 0xe6, 0x78, 0xcd, 0x65, 0xb8, 0x72, 0x9a, 0xf1, 0x66, 0xc5, 0x23, 0x63,
+	0x15, 0x06, 0x71, 0x80, 0x9e, 0xfb, 0x3c, 0x30, 0x16, 0x91, 0xb1, 0x6e, 0x19, 0xcc, 0xf1, 0x6a,
+	0xd5, 0x75, 0xab, 0x19, 0xf2, 0x45, 0xf4, 0x01, 0xf0, 0xf4, 0x3f, 0x15, 0x00, 0x9b, 0x9d, 0x21,
+	0xe1, 0x4e, 0x10, 0xce, 0xd1, 0xd7, 0x50, 0x0a, 0x56, 0x3c, 0x64, 0xb1, 0x1b, 0xf8, 0x55, 0xe5,
+	0x44, 0x39, 0xfb, 0xa4, 0x55, 0x35, 0x1e, 0xcd, 0x32, 0xac, 0x6d, 0x9f, 0x94, 0x1e, 0x4a, 0xd4,
+	0x80, 0x3c, 0x73, 0x24, 0x29, 0x27, 0x49, 0x2f, 0x32, 0x24, 0x53, 0x36, 0x49, 0x3e, 0xf9, 0x45,
+	0x6f, 0xa0, 0xb0, 0x70, 0xbd, 0x98, 0x87, 0x51, 0x55, 0x3d, 0x51, 0xcf, 0xca, 0xad, 0x2f, 0x32,
+	0xf8, 0x9d, 0x25, 0xe3, 0x42, 0x02, 0x07, 0xfe, 0x22, 0x20, 0x85, 0xa4, 0x8e, 0x04, 0x3f, 0x66,
+	0xe1, 0x92, 0xc7, 0x51, 0x55, 0x7b, 0x8a, 0x4f, 0x25, 0x30, 0xe1, 0x27, 0x75, 0x54, 0xfb, 0x53,
+	0x01, 0xd8, 0xcd, 0x45, 0xaf, 0x20, 0x7f, 0xc3, 0xd9, 0x9c, 0x87, 0xe9, 0x96, 0x8f, 0x32, 0xd3,
+	0xfa, 0xb2, 0x49, 0x37, 0x2b, 0x4e, 0x60, 0x57, 0xa3, 0xd7, 0x00, 0xb7, 0x2c, 0x76, 0x6e, 0xa6,
+	0x22, 0xd0, 0x74, 0xe3, 0xd9, 0xb4, 0x2e, 0x05, 0x40, 0x32, 0x4b, 0x0f, 0x25, 0x3a, 0x82, 0x72,
+	0xa2, 0x37, 0xf5, 0xd9, 0x2d, 0xaf, 0xaa, 0x27, 0xca, 0x59, 0x89, 0x68, 0x23, 0x76, 0x2b, 0x5a,
+	0x90, 0xb6, 0xd6, 0xcc, 0xab, 0x6a, 0xb2, 0x73, 0xf0, 0x96, 0x79, 0x77, 0xbc, 0x76, 0x05, 0xb0,
+	0xdb, 0x0b, 0xfa, 0x12, 0xf2, 0x49, 0x04, 0xa9, 0xe7, 0x6c, 0xe2, 0x09, 0x94, 0x68, 0x24, 0xf0,
+	0x38, 0xaa, 0x40, 0xf1, 0x1d, 0xdf, 0x4c, 0x3d, 0x37, 0x8a, 0xab, 0xb9, 0x13, 0xf5, 0xec, 0x90,
+	0x68, 0xdf, 0xf3, 0x4d, 0x74, 0xfa, 0x8b, 0x02, 0x25, 0x11, 0x15, 0x65, 0x33, 0x8f, 0xa3, 0x37,
+	0x70, 0xe8, 0x04, 0x7e, 0xcc, 0x5c, 0x9f, 0x87, 0x53, 0x77, 0x2e, 0x07, 0x97, 0x5b, 0x9f, 0xed,
+	0x0d, 0x16, 0x77, 0xc8, 0xe8, 0x6c, 0x31, 0x83, 0x2e, 0x29, 0xef, 0x7d, 0xa0, 0x73, 0x28, 0x84,
+	0x32, 0xf3, 0x48, 0x8a, 0x94, 0x3f, 0xc8, 0x71, 0x77, 0x2a, 0xa4, 0x90, 0xfc, 0x46, 0xa7, 0xbf,
+	0xaa, 0x50, 0x6e, 0x73, 0x16, 0xf2, 0x90, 0x06, 0xef, 0xb8, 0x8f, 0xce, 0x41, 0x9b, 0x05, 0xf3,
+	0x4d, 0x2a, 0xfe, 0x79, 0x66, 0xc2, 0x1e, 0xd2, 0x68, 0x07, 0xf3, 0x0d, 0x91, 0x60, 0xf4, 0x1a,
+	0x4a, 0x91, 0xbb, 0xf4, 0x59, 0x7c, 0x17, 0x26, 0x07, 0xf1, 0x58, 0x5b, 0xda, 0xb6, 0xb7, 0x00,
+	0xb2, 0xc3, 0xd6, 0x7e, 0xcb, 0x81, 0xd6, 0x4e, 0x26, 0x00, 0x67, 0x8e, 0x37, 0x8d, 0x45, 0x12,
+	0xa9, 0x78, 0xf5, 0x23, 0xf6, 0x65, 0x52, 0xa4, 0x24, 0xb0, 0x49, 0x68, 0x2d, 0x28, 0x06, 0xef,
+	0xd3, 0xc0, 0x12, 0xe5, 0x97, 0x59, 0x65, 0xeb, 0x7d, 0x12, 0x56, 0x41, 0x02, 0x07, 0x73, 0x34,
+	0x80, 0xa2, 0xe7, 0x2e, 0x78, 0xec, 0xa6, 0x87, 0x5f, 0x6e, 0x35, 0x9e, 0xd8, 0xa7, 0x21, 0xcb,
+	0x61, 0x4a, 0x22, 0x0f, 0xf4, 0x1a, 0x86, 0xe7, 0x8f, 0x5a, 0x48, 0x07, 0x95, 0xff, 0xb4, 0x92,
+	0x3b, 0xd0, 0x88, 0x28, 0xc5, 0x8a, 0x3f, 0x5b, 0x48, 0x73, 0x1a, 0x11, 0xa5, 0x58, 0x71, 0x59,
+	0x2c, 0xa5, 0x35, 0x22, 0xca, 0x7a, 0x1b, 0xf2, 0xc9, 0x85, 0x41, 0x15, 0x40, 0xd4, 0x24, 0x3d,
+	0x4c, 0xa7, 0x93, 0x91, 0x3d, 0xc6, 0x9d, 0xc1, 0xc5, 0x00, 0x77, 0xf5, 0x67, 0xa8, 0x08, 0xda,
+	0xc4, 0xc6, 0x44, 0x57, 0x10, 0x40, 0xde, 0xbe, 0xb6, 0x29, 0xbe, 0xd4, 0x73, 0xa2, 0xb6, 0x68,
+	0x1f, 0x13, 0x5b, 0x57, 0xeb, 0x16, 0xec, 0x5d, 0xf1, 0x1a, 0x54, 0x2e, 0x4d, 0xda, 0xe9, 0x4f,
+	0xe9, 0xf5, 0x18, 0x67, 0x46, 0xe9, 0x70, 0x68, 0x53, 0x32, 0x18, 0xf5, 0xa6, 0xf8, 0x6a, 0x62,
+	0x0e, 0x75, 0x05, 0x7d, 0x0a, 0x7a, 0xba, 0x32, 0xb2, 0x68, 0xba, 0x9a, 0xab, 0xff, 0x0c, 0x7b,
+	0x2f, 0xcc, 0x11, 0xbc, 0xb0, 0xc6, 0x98, 0x98, 0x74, 0x60, 0x8d, 0x32, 0xf3, 0x0a, 0xa0, 0xf6,
+	0x30, 0xd5, 0x15, 0xe1, 0xb1, 0x8f, 0xcd, 0xae, 0x9e, 0x13, 0x4b, 0xe3, 0x09, 0xd5, 0x55, 0x61,
+	0xb0, 0x8b, 0x87, 0x98, 0x62, 0x5d, 0x93, 0xc6, 0xb1, 0x49, 0x3a, 0x7d, 0xfd, 0x00, 0x1d, 0x42,
+	0xb1, 0x87, 0x29, 0x31, 0x47, 0x3d, 0xac, 0xe7, 0x85, 0xa3, 0xed, 0x57, 0xdf, 0xb4, 0xfb, 0x7a,
+	0xa1, 0xfe, 0x0a, 0xb6, 0x6f, 0x55, 0x05, 0x90, 0xd9, 0xf9, 0x88, 0x6a, 0x09, 0x0e, 0xcc, 0xe1,
+	0xd0, 0xfa, 0x21, 0xd1, 0xed, 0xe2, 0xd1, 0xb5, 0x9e, 0xab, 0x7f, 0x0b, 0xfb, 0x0f, 0x44, 0x05,
+	0x90, 0xf0, 0x83, 0x49, 0x86, 0x5a, 0x86, 0x02, 0xc1, 0x57, 0x13, 0x6c, 0xd3, 0x24, 0x4e, 0xab,
+	0xfd, 0x1d, 0xee, 0x50, 0x3d, 0xd7, 0x7e, 0xfb, 0xd7, 0xfd, 0xb1, 0xf2, 0xf7, 0xfd, 0xb1, 0xf2,
+	0xcf, 0xfd, 0xb1, 0xf2, 0xfb, 0xbf, 0xc7, 0xcf, 0x7e, 0xfc, 0x6a, 0xe9, 0xc6, 0x37, 0x77, 0x33,
+	0xc3, 0x09, 0x6e, 0x9b, 0x7e, 0xb4, 0x72, 0x9c, 0xc6, 0x9c, 0xaf, 0x9b, 0x3e, 0x0f, 0x16, 0x51,
+	0x83, 0xad, 0xdc, 0xc6, 0x32, 0x68, 0xee, 0xfd, 0x07, 0x7c, 0xc3, 0x1c, 0xef, 0x8f, 0x9c, 0x3e,
+	0xe2, 0xc1, 0x85, 0x6d, 0x98, 0xe3, 0x81, 0xb8, 0x4e, 0xa6, 0xe3, 0xcd, 0xf2, 0xf2, 0xb1, 0x3f,
+	0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x9c, 0x67, 0x62, 0x30, 0x06, 0x00, 0x00,
 }
 
 func (m *EACLRecord) Marshal() (dAtA []byte, err error) {
@@ -749,6 +954,162 @@ func (m *EACLTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *BearerToken) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BearerToken) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BearerToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Signature != nil {
+		{
+			size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Body != nil {
+		{
+			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *BearerToken_Body) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BearerToken_Body) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BearerToken_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Lifetime != nil {
+		{
+			size, err := m.Lifetime.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.OwnerId != nil {
+		{
+			size, err := m.OwnerId.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.EaclTable != nil {
+		{
+			size, err := m.EaclTable.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *BearerToken_Body_TokenLifetime) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BearerToken_Body_TokenLifetime) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BearerToken_Body_TokenLifetime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Iat != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Iat))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.Nbf != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Nbf))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Exp != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Exp))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTypes(v)
 	base := offset
@@ -859,6 +1220,71 @@ func (m *EACLTable) Size() (n int) {
 	return n
 }
 
+func (m *BearerToken) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Body != nil {
+		l = m.Body.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.Signature != nil {
+		l = m.Signature.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *BearerToken_Body) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.EaclTable != nil {
+		l = m.EaclTable.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.OwnerId != nil {
+		l = m.OwnerId.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.Lifetime != nil {
+		l = m.Lifetime.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *BearerToken_Body_TokenLifetime) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Exp != 0 {
+		n += 1 + sovTypes(uint64(m.Exp))
+	}
+	if m.Nbf != 0 {
+		n += 1 + sovTypes(uint64(m.Nbf))
+	}
+	if m.Iat != 0 {
+		n += 1 + sovTypes(uint64(m.Iat))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func sovTypes(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -1410,6 +1836,405 @@ func (m *EACLTable) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *BearerToken) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: BearerToken: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BearerToken: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Body == nil {
+				m.Body = &BearerToken_Body{}
+			}
+			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Signature == nil {
+				m.Signature = &grpc.Signature{}
+			}
+			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Body: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EaclTable", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.EaclTable == nil {
+				m.EaclTable = &EACLTable{}
+			}
+			if err := m.EaclTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OwnerId", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.OwnerId == nil {
+				m.OwnerId = &grpc.OwnerID{}
+			}
+			if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Lifetime == nil {
+				m.Lifetime = &BearerToken_Body_TokenLifetime{}
+			}
+			if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *BearerToken_Body_TokenLifetime) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TokenLifetime: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TokenLifetime: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Exp", wireType)
+			}
+			m.Exp = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Exp |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Nbf", wireType)
+			}
+			m.Nbf = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Nbf |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Iat", wireType)
+			}
+			m.Iat = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Iat |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTypes(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/v2/container/grpc/service.pb.go b/v2/container/grpc/service.pb.go
index 04a48a8..dd3791f 100644
--- a/v2/container/grpc/service.pb.go
+++ b/v2/container/grpc/service.pb.go
@@ -9,7 +9,7 @@ import (
 	proto "github.com/golang/protobuf/proto"
 	grpc2 "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
 	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
+	grpc "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	grpc3 "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -104,10 +104,10 @@ type PutRequest_Body struct {
 	// Container to create in NeoFS.
 	Container *Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container,omitempty"`
 	//Signature of stable-marshalled container according to RFC-6979.
-	Signature            *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	Signature            *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *PutRequest_Body) Reset()         { *m = PutRequest_Body{} }
@@ -150,7 +150,7 @@ func (m *PutRequest_Body) GetContainer() *Container {
 	return nil
 }
 
-func (m *PutRequest_Body) GetSignature() *grpc.Signature {
+func (m *PutRequest_Body) GetSignature() *grpc1.Signature {
 	if m != nil {
 		return m.Signature
 	}
@@ -352,10 +352,10 @@ type DeleteRequest_Body struct {
 	// from NeoFS.
 	ContainerId *grpc1.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
 	// Signature of container id according to RFC-6979.
-	Signature            *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	Signature            *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *DeleteRequest_Body) Reset()         { *m = DeleteRequest_Body{} }
@@ -398,7 +398,7 @@ func (m *DeleteRequest_Body) GetContainerId() *grpc1.ContainerID {
 	return nil
 }
 
-func (m *DeleteRequest_Body) GetSignature() *grpc.Signature {
+func (m *DeleteRequest_Body) GetSignature() *grpc1.Signature {
 	if m != nil {
 		return m.Signature
 	}
@@ -1067,10 +1067,10 @@ type SetExtendedACLRequest_Body struct {
 	// Extended ACL to set for the container.
 	Eacl *grpc2.EACLTable `protobuf:"bytes,1,opt,name=eacl,proto3" json:"eacl,omitempty"`
 	// Signature of stable-marshalled Extended ACL according to RFC-6979.
-	Signature            *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	Signature            *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *SetExtendedACLRequest_Body) Reset()         { *m = SetExtendedACLRequest_Body{} }
@@ -1113,7 +1113,7 @@ func (m *SetExtendedACLRequest_Body) GetEacl() *grpc2.EACLTable {
 	return nil
 }
 
-func (m *SetExtendedACLRequest_Body) GetSignature() *grpc.Signature {
+func (m *SetExtendedACLRequest_Body) GetSignature() *grpc1.Signature {
 	if m != nil {
 		return m.Signature
 	}
@@ -1424,10 +1424,10 @@ type GetExtendedACLResponse_Body struct {
 	// Extended ACL that has been requested if it was set up.
 	Eacl *grpc2.EACLTable `protobuf:"bytes,1,opt,name=eacl,proto3" json:"eacl,omitempty"`
 	// Signature of stable-marshalled Extended ACL according to RFC-6979.
-	Signature            *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	Signature            *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *GetExtendedACLResponse_Body) Reset()         { *m = GetExtendedACLResponse_Body{} }
@@ -1470,7 +1470,7 @@ func (m *GetExtendedACLResponse_Body) GetEacl() *grpc2.EACLTable {
 	return nil
 }
 
-func (m *GetExtendedACLResponse_Body) GetSignature() *grpc.Signature {
+func (m *GetExtendedACLResponse_Body) GetSignature() *grpc1.Signature {
 	if m != nil {
 		return m.Signature
 	}
@@ -1507,58 +1507,59 @@ func init() {
 func init() { proto.RegisterFile("v2/container/grpc/service.proto", fileDescriptor_364186d99410ec35) }
 
 var fileDescriptor_364186d99410ec35 = []byte{
-	// 813 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x98, 0xcf, 0x6e, 0xd3, 0x5a,
-	0x10, 0xc6, 0xaf, 0xdd, 0xa8, 0xf7, 0x76, 0x92, 0x56, 0x57, 0xbe, 0x6a, 0x1b, 0xa5, 0x97, 0x34,
-	0x18, 0x0a, 0x15, 0x34, 0x36, 0x32, 0x1b, 0x68, 0x0b, 0xa2, 0x4d, 0x5a, 0x37, 0xa2, 0x40, 0xeb,
-	0x20, 0x16, 0x6c, 0x2a, 0xc7, 0x9e, 0xa4, 0x96, 0x52, 0x3b, 0xd8, 0x8e, 0x4b, 0x76, 0xa8, 0x4f,
-	0xc1, 0x02, 0xb1, 0x46, 0x15, 0x0b, 0x9e, 0x80, 0x35, 0x4b, 0x1e, 0x01, 0xb5, 0x1b, 0x24, 0x58,
-	0xf1, 0x04, 0x28, 0xfe, 0x17, 0xbb, 0x71, 0x9a, 0xa4, 0x8d, 0x90, 0xbc, 0x4b, 0xe4, 0x6f, 0xe6,
-	0xcc, 0xfc, 0xf2, 0x9d, 0x33, 0xc7, 0x81, 0x79, 0x8b, 0x63, 0x25, 0x4d, 0x35, 0x45, 0x45, 0x45,
-	0x9d, 0xad, 0xe9, 0x0d, 0x89, 0x35, 0x50, 0xb7, 0x14, 0x09, 0x99, 0x86, 0xae, 0x99, 0x1a, 0xf5,
-	0x9f, 0x8a, 0x1a, 0x53, 0x35, 0x18, 0x8b, 0x63, 0x7c, 0x5d, 0x66, 0xd6, 0xe2, 0x58, 0x51, 0xaa,
-	0x3b, 0x7a, 0xb3, 0xd5, 0x40, 0xc3, 0x51, 0x67, 0xae, 0x74, 0xa7, 0x0b, 0x3e, 0x4e, 0x5b, 0x1c,
-	0xab, 0x63, 0xd5, 0xe8, 0x7e, 0x32, 0x67, 0x71, 0xde, 0xc2, 0x5d, 0x0f, 0xe9, 0x53, 0x12, 0x60,
-	0xa7, 0x69, 0x0a, 0xf8, 0xaa, 0x89, 0x86, 0x49, 0xdd, 0x83, 0x44, 0x45, 0x93, 0x5b, 0x69, 0x22,
-	0x47, 0x2c, 0x26, 0xb9, 0xeb, 0x4c, 0x44, 0x85, 0x4c, 0x47, 0xce, 0xac, 0x6b, 0x72, 0x4b, 0xb0,
-	0x23, 0xa8, 0x0d, 0x48, 0x1e, 0xa0, 0x29, 0xee, 0xed, 0xa3, 0x28, 0xa3, 0x9e, 0x26, 0xbb, 0x12,
-	0x78, 0xbd, 0xbb, 0xb1, 0x4f, 0xd0, 0x14, 0xb7, 0x6c, 0xad, 0x00, 0x07, 0xfe, 0x67, 0x6a, 0x17,
-	0x26, 0x2d, 0xd4, 0x95, 0x6a, 0xcb, 0x4b, 0x34, 0x66, 0x27, 0x5a, 0xea, 0x9d, 0xe8, 0x45, 0x5b,
-	0xae, 0x48, 0xa2, 0xa9, 0x68, 0xaa, 0x9b, 0x30, 0xe5, 0xa4, 0x70, 0xbe, 0x65, 0xde, 0x10, 0x90,
-	0x68, 0x17, 0x4a, 0xad, 0xc2, 0x84, 0xdf, 0x85, 0xdb, 0x61, 0x36, 0xb2, 0xc3, 0x82, 0xf7, 0x49,
-	0xe8, 0x04, 0x50, 0xcb, 0x30, 0x61, 0x28, 0x35, 0x55, 0x34, 0x9b, 0x3a, 0xba, 0xed, 0xfd, 0x1f,
-	0x51, 0x55, 0xd9, 0xd3, 0x08, 0x1d, 0x39, 0xfd, 0x91, 0x84, 0xa4, 0x8d, 0xcd, 0x68, 0x68, 0xaa,
-	0x81, 0xd4, 0xfd, 0x10, 0xe6, 0x85, 0xde, 0x98, 0x1d, 0x7d, 0x90, 0xf3, 0x66, 0x14, 0xe7, 0x85,
-	0x48, 0x3c, 0x4e, 0x70, 0x0f, 0xd0, 0x42, 0x34, 0xe8, 0xfc, 0x39, 0x99, 0xfa, 0x92, 0xde, 0x74,
-	0x41, 0x3f, 0x84, 0x94, 0xdf, 0xc7, 0x9e, 0x22, 0xbb, 0x6d, 0xce, 0x05, 0x52, 0xb7, 0x9d, 0xda,
-	0xc1, 0x5c, 0x2a, 0x0a, 0x49, 0x3f, 0xa0, 0x24, 0xd3, 0x3f, 0x48, 0x98, 0x2c, 0x62, 0x1d, 0x4d,
-	0xf4, 0x7c, 0xb9, 0x12, 0x02, 0x76, 0x33, 0x12, 0x58, 0x28, 0x22, 0x1e, 0xd6, 0x3c, 0x22, 0x46,
-	0x43, 0xec, 0x52, 0xe6, 0xfc, 0x45, 0xc0, 0x94, 0xc7, 0xce, 0xf5, 0xe7, 0x6a, 0x08, 0xf7, 0xe2,
-	0xb9, 0xb8, 0xe3, 0x65, 0xd1, 0x71, 0x07, 0x38, 0xfd, 0x81, 0x04, 0xe0, 0x71, 0xa8, 0x73, 0xaf,
-	0x23, 0x8f, 0x87, 0xb9, 0x46, 0xb5, 0x1b, 0x8f, 0x49, 0x48, 0xda, 0xbd, 0x0f, 0x71, 0x78, 0x05,
-	0xf4, 0x71, 0x71, 0x46, 0x71, 0x14, 0x53, 0x82, 0x7e, 0x4f, 0x42, 0x72, 0x5b, 0x31, 0x7c, 0x63,
-	0x0d, 0x02, 0x2b, 0xa0, 0x8f, 0x87, 0xb3, 0x96, 0x5d, 0x54, 0x1c, 0xfc, 0xa3, 0x1d, 0x86, 0x5c,
-	0x35, 0x7b, 0xd6, 0x55, 0xcf, 0x0e, 0x1d, 0x47, 0xfd, 0x6d, 0x0b, 0x4b, 0x32, 0xfd, 0x89, 0x84,
-	0x94, 0xd3, 0xb0, 0x6b, 0xa7, 0xe5, 0x10, 0xa1, 0x1b, 0xe7, 0x10, 0x8a, 0x97, 0x9f, 0xb6, 0x5c,
-	0x48, 0x8f, 0x60, 0x32, 0xb8, 0xfd, 0x8c, 0x34, 0x91, 0x1b, 0xeb, 0xb7, 0xff, 0x52, 0x81, 0xfd,
-	0x67, 0xd0, 0xdf, 0x49, 0x98, 0x2e, 0xa3, 0xb9, 0xf1, 0xda, 0x44, 0x55, 0x46, 0x79, 0xad, 0xb0,
-	0xed, 0xb9, 0xab, 0x10, 0x62, 0xc7, 0x46, 0xb2, 0x8b, 0x8c, 0x8c, 0x87, 0xcf, 0x1a, 0x2e, 0xc2,
-	0x25, 0x48, 0xa0, 0x28, 0xd5, 0xdd, 0x36, 0xd3, 0x81, 0x8c, 0xa2, 0x54, 0x67, 0x36, 0xd6, 0x0a,
-	0xdb, 0xcf, 0xc5, 0x4a, 0x1d, 0x05, 0x5b, 0x75, 0xa9, 0x59, 0x78, 0x44, 0xc2, 0xcc, 0x59, 0x60,
-	0xae, 0x4f, 0x8b, 0x21, 0xd6, 0x77, 0x06, 0x62, 0x1d, 0xcf, 0xd9, 0xf8, 0x99, 0x84, 0x69, 0xfe,
-	0xc2, 0x7e, 0xe3, 0xe3, 0xeb, 0xb7, 0x51, 0x4d, 0xcc, 0x9f, 0x24, 0xcc, 0xf0, 0x17, 0x77, 0x11,
-	0x1f, 0x6b, 0x17, 0xfd, 0xf1, 0x4d, 0xcb, 0xbd, 0x4b, 0xc0, 0xbf, 0xfe, 0x6f, 0x51, 0x76, 0x94,
-	0xd4, 0x16, 0x8c, 0xed, 0x34, 0x4d, 0x6a, 0xbe, 0xcf, 0x2b, 0x6c, 0x26, 0xd7, 0xef, 0xe5, 0x8b,
-	0xda, 0x85, 0x71, 0xe7, 0xae, 0x4b, 0xd1, 0xfd, 0xdf, 0x3b, 0x32, 0xd7, 0x06, 0xb8, 0x2c, 0xb7,
-	0x8b, 0xe3, 0xb1, 0x57, 0x71, 0x9d, 0x7b, 0x66, 0x8f, 0xe2, 0x82, 0x97, 0xb1, 0xc7, 0x90, 0x68,
-	0x0f, 0x47, 0x2a, 0xd7, 0xef, 0x66, 0x91, 0xb9, 0xda, 0x77, 0xb2, 0x52, 0x0a, 0x4c, 0x85, 0x4f,
-	0x30, 0xea, 0xd6, 0xe0, 0x23, 0x25, 0x73, 0x7b, 0x88, 0x23, 0xb1, 0xbd, 0x14, 0x3f, 0xc8, 0x52,
-	0xfc, 0x10, 0x4b, 0x45, 0xef, 0x9b, 0xf5, 0xfd, 0x2f, 0x27, 0x59, 0xe2, 0xeb, 0x49, 0x96, 0xf8,
-	0x76, 0x92, 0x25, 0xde, 0x9e, 0x66, 0xff, 0x7a, 0xf9, 0xa0, 0xa6, 0x98, 0xfb, 0xcd, 0x0a, 0x23,
-	0x69, 0x07, 0xac, 0x6a, 0x34, 0x24, 0x29, 0x2f, 0xa3, 0xc5, 0xaa, 0xa8, 0x55, 0x8d, 0xbc, 0xd8,
-	0x50, 0xf2, 0x35, 0x8d, 0xed, 0xfa, 0xb3, 0x65, 0xc5, 0xff, 0x7a, 0x4c, 0xce, 0x3c, 0x45, 0x6d,
-	0xb3, 0xcc, 0xac, 0xed, 0x94, 0xda, 0x05, 0xf8, 0xd6, 0xab, 0x8c, 0xdb, 0xff, 0xa9, 0xdc, 0xfd,
-	0x1d, 0x00, 0x00, 0xff, 0xff, 0x27, 0xf9, 0x1d, 0xbb, 0xfa, 0x11, 0x00, 0x00,
+	// 821 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x98, 0xcf, 0x6e, 0xd3, 0x58,
+	0x14, 0xc6, 0x27, 0x6e, 0xd4, 0x99, 0x9e, 0xa4, 0xd5, 0xc8, 0xa3, 0xb6, 0x99, 0x54, 0x93, 0x66,
+	0x3c, 0xd3, 0x99, 0x0a, 0x1a, 0x1b, 0x99, 0x05, 0xd0, 0x16, 0x44, 0x9b, 0xb4, 0x6e, 0x44, 0x81,
+	0xd6, 0x41, 0x2c, 0xd8, 0x54, 0x8e, 0x7d, 0x92, 0x5a, 0x4a, 0xec, 0xe0, 0xeb, 0xb8, 0x64, 0x81,
+	0x90, 0x78, 0x0a, 0x16, 0x88, 0x35, 0xaa, 0x58, 0xf0, 0x04, 0xac, 0x59, 0xf2, 0x06, 0xa0, 0x22,
+	0x84, 0xd8, 0xf2, 0x04, 0x28, 0xb6, 0xe3, 0xd8, 0x8d, 0xd3, 0xfc, 0x51, 0x84, 0xe4, 0x5d, 0x22,
+	0x7f, 0xe7, 0xf8, 0x9c, 0x5f, 0xbe, 0x7b, 0xcf, 0xbd, 0x81, 0x65, 0x8b, 0xe7, 0x64, 0x5d, 0x33,
+	0x25, 0x55, 0x43, 0x83, 0xab, 0x1a, 0x0d, 0x99, 0x23, 0x68, 0x58, 0xaa, 0x8c, 0x6c, 0xc3, 0xd0,
+	0x4d, 0x9d, 0xfe, 0x43, 0x43, 0x9d, 0xad, 0x10, 0xd6, 0xe2, 0x59, 0x4f, 0x97, 0x5e, 0xb4, 0x78,
+	0x4e, 0x92, 0x6b, 0x8e, 0xde, 0x6c, 0x35, 0x90, 0x38, 0xea, 0xf4, 0x5f, 0xbd, 0xe9, 0xfc, 0x8f,
+	0x53, 0x16, 0xcf, 0x19, 0x58, 0x21, 0xbd, 0x4f, 0x96, 0x2c, 0x9e, 0x23, 0x48, 0x88, 0xaa, 0x6b,
+	0x3d, 0x0f, 0x99, 0x8f, 0x14, 0xc0, 0x41, 0xd3, 0x14, 0xf1, 0x71, 0x13, 0x89, 0x49, 0x5f, 0x87,
+	0x78, 0x59, 0x57, 0x5a, 0xa9, 0x58, 0x36, 0xb6, 0x9a, 0xe0, 0xff, 0x65, 0x43, 0x2a, 0x64, 0xbb,
+	0x72, 0x76, 0x5b, 0x57, 0x5a, 0xa2, 0x1d, 0x41, 0xef, 0x40, 0xa2, 0x8e, 0xa6, 0x74, 0x74, 0x8c,
+	0x92, 0x82, 0x46, 0x8a, 0xea, 0x49, 0xe0, 0x96, 0xc0, 0xba, 0xb1, 0x77, 0xd1, 0x94, 0xf6, 0x6c,
+	0xad, 0x08, 0x75, 0xef, 0x33, 0x7d, 0x08, 0xb3, 0x16, 0x1a, 0x6a, 0xa5, 0xd5, 0x49, 0x34, 0x65,
+	0x27, 0x5a, 0xeb, 0x9f, 0xe8, 0x61, 0x5b, 0xae, 0xca, 0x92, 0xa9, 0xea, 0x9a, 0x9b, 0x30, 0xe9,
+	0xa4, 0x70, 0xbe, 0xa5, 0x9f, 0x42, 0xbc, 0x5d, 0x27, 0xbd, 0x09, 0x33, 0x5e, 0x13, 0x6e, 0x83,
+	0x99, 0xd0, 0x06, 0xf3, 0x9d, 0x4f, 0x62, 0x37, 0x80, 0xbe, 0x06, 0x33, 0x44, 0xad, 0x6a, 0x92,
+	0xd9, 0x34, 0xd0, 0xed, 0xee, 0x4f, 0x5f, 0x74, 0x1b, 0x3d, 0x5b, 0xea, 0x08, 0xc4, 0xae, 0x96,
+	0x79, 0x43, 0x41, 0xc2, 0x46, 0x46, 0x1a, 0xba, 0x46, 0x90, 0xbe, 0x11, 0x40, 0xbc, 0xd2, 0x1f,
+	0xb1, 0xa3, 0xf7, 0x33, 0xde, 0x0d, 0x63, 0xbc, 0x12, 0x8a, 0xc6, 0x09, 0xee, 0x03, 0x59, 0x0c,
+	0x87, 0x9c, 0xbb, 0x20, 0xd3, 0x40, 0xca, 0xbb, 0x2e, 0xe5, 0x5b, 0x90, 0xf4, 0xfa, 0x38, 0x52,
+	0x15, 0xb7, 0xcd, 0xa5, 0xf3, 0xa8, 0x3c, 0xc6, 0xc5, 0x82, 0x98, 0xf0, 0x02, 0x8a, 0x0a, 0xf3,
+	0x95, 0x82, 0xd9, 0x02, 0xd6, 0xd0, 0xc4, 0x8e, 0x27, 0x37, 0x02, 0xc0, 0xfe, 0x0f, 0x05, 0x16,
+	0x88, 0x88, 0x86, 0x2d, 0x9f, 0x4d, 0x06, 0xd8, 0xf8, 0xc6, 0xfc, 0x1e, 0x83, 0xb9, 0x0e, 0x37,
+	0xd7, 0x9b, 0x9b, 0x01, 0xd4, 0xab, 0x17, 0xa2, 0x8e, 0x96, 0x3d, 0xa7, 0x1d, 0xda, 0xcc, 0x6b,
+	0x0a, 0x40, 0xc0, 0x91, 0xf6, 0xbb, 0xae, 0x3c, 0x1a, 0xc6, 0x9a, 0xd4, 0x4a, 0x3c, 0xa5, 0x20,
+	0x61, 0xf7, 0x3e, 0xc2, 0xc6, 0xe5, 0xd3, 0x47, 0xc5, 0x19, 0x85, 0x49, 0x8c, 0x07, 0xe6, 0x15,
+	0x05, 0x89, 0x7d, 0x95, 0x78, 0xc6, 0x1a, 0x06, 0x96, 0x4f, 0x1f, 0x0d, 0x67, 0xad, 0xbb, 0xa8,
+	0x78, 0xf8, 0x4d, 0x3f, 0x09, 0xb8, 0x6a, 0xf1, 0xbc, 0xab, 0xee, 0x9f, 0x38, 0x8e, 0xfa, 0xd5,
+	0x16, 0x16, 0x15, 0xe6, 0x2d, 0x05, 0x49, 0xa7, 0x61, 0xd7, 0x4e, 0xeb, 0x01, 0x42, 0xff, 0x5d,
+	0x40, 0x28, 0x5a, 0x7e, 0xda, 0x73, 0x21, 0xdd, 0x86, 0x59, 0xff, 0xf2, 0x23, 0xa9, 0x58, 0x76,
+	0x6a, 0xd0, 0xfa, 0x4b, 0xfa, 0xd6, 0x1f, 0x61, 0xbe, 0x50, 0x30, 0x5f, 0x42, 0x73, 0xe7, 0x89,
+	0x89, 0x9a, 0x82, 0xca, 0x56, 0x7e, 0xbf, 0xe3, 0xae, 0x7c, 0x80, 0x1d, 0x17, 0xca, 0x2e, 0x34,
+	0x32, 0x1a, 0x3e, 0xab, 0xbb, 0x08, 0xd7, 0x20, 0x8e, 0x92, 0x5c, 0x73, 0xdb, 0x4c, 0xf9, 0x32,
+	0x4a, 0x72, 0x8d, 0xdd, 0xd9, 0xca, 0xef, 0x3f, 0x90, 0xca, 0x35, 0x14, 0x6d, 0xd5, 0xf8, 0x83,
+	0xf0, 0x39, 0x05, 0x0b, 0xe7, 0x69, 0xb9, 0x26, 0x2d, 0x04, 0x40, 0x5f, 0x19, 0x0a, 0x74, 0x34,
+	0x07, 0xe3, 0x3b, 0x0a, 0xe6, 0x85, 0xb1, 0xcd, 0x26, 0x44, 0xd7, 0x6c, 0x93, 0x1a, 0x97, 0xdf,
+	0x28, 0x58, 0x10, 0xc6, 0x77, 0x91, 0x10, 0x69, 0x17, 0xfd, 0xdc, 0x15, 0xcb, 0xbf, 0x8c, 0xc3,
+	0xef, 0xde, 0x0f, 0x51, 0x72, 0x2e, 0xd5, 0xf4, 0x1e, 0x4c, 0x1d, 0x34, 0x4d, 0x7a, 0x79, 0xc0,
+	0xa5, 0x35, 0x9d, 0x1d, 0x74, 0xe5, 0xa2, 0x0f, 0x61, 0xda, 0x39, 0xe5, 0xd2, 0xcc, 0xe0, 0xdb,
+	0x46, 0xfa, 0x9f, 0x21, 0x8e, 0xc9, 0xed, 0xe2, 0x04, 0xec, 0x57, 0x5c, 0xf7, 0x84, 0xd9, 0xa7,
+	0x38, 0xff, 0x31, 0xec, 0x0e, 0xc4, 0xdb, 0x63, 0x91, 0xce, 0x0e, 0x3a, 0x53, 0xa4, 0xff, 0x1e,
+	0x38, 0x53, 0x69, 0x15, 0xe6, 0x82, 0xdb, 0x17, 0x7d, 0x69, 0xf8, 0x61, 0x92, 0xbe, 0x3c, 0xc2,
+	0x7e, 0xd8, 0x7e, 0x95, 0x30, 0xcc, 0xab, 0x84, 0x11, 0x5e, 0x15, 0xbe, 0x68, 0xb6, 0x8f, 0xdf,
+	0x9f, 0x65, 0x62, 0x1f, 0xce, 0x32, 0xb1, 0x4f, 0x67, 0x99, 0xd8, 0x8b, 0xcf, 0x99, 0x5f, 0x1e,
+	0xdd, 0xac, 0xaa, 0xe6, 0x71, 0xb3, 0xcc, 0xca, 0x7a, 0x9d, 0xd3, 0x48, 0x43, 0x96, 0x73, 0x0a,
+	0x5a, 0x9c, 0x86, 0x7a, 0x85, 0xe4, 0xa4, 0x86, 0x9a, 0xab, 0xea, 0x5c, 0xcf, 0xdf, 0x2b, 0x1b,
+	0xde, 0xd7, 0x53, 0x6a, 0xe1, 0x1e, 0xea, 0xbb, 0x25, 0x76, 0xeb, 0xa0, 0xd8, 0x2e, 0xc0, 0xb3,
+	0x5e, 0x79, 0xda, 0xfe, 0x17, 0xe5, 0xea, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x09, 0xe6,
+	0xa5, 0xec, 0x11, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3867,7 +3868,7 @@ func (m *PutRequest_Body) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Signature == nil {
-				m.Signature = &grpc.Signature{}
+				m.Signature = &grpc1.Signature{}
 			}
 			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -4407,7 +4408,7 @@ func (m *DeleteRequest_Body) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Signature == nil {
-				m.Signature = &grpc.Signature{}
+				m.Signature = &grpc1.Signature{}
 			}
 			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -5917,7 +5918,7 @@ func (m *SetExtendedACLRequest_Body) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Signature == nil {
-				m.Signature = &grpc.Signature{}
+				m.Signature = &grpc1.Signature{}
 			}
 			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -6673,7 +6674,7 @@ func (m *GetExtendedACLResponse_Body) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Signature == nil {
-				m.Signature = &grpc.Signature{}
+				m.Signature = &grpc1.Signature{}
 			}
 			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
diff --git a/v2/container/grpc/types.pb.go b/v2/container/grpc/types.pb.go
index 97979f1..4d48b1b 100644
--- a/v2/container/grpc/types.pb.go
+++ b/v2/container/grpc/types.pb.go
@@ -6,9 +6,8 @@ package container
 import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc2 "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
-	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
+	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
+	grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -34,7 +33,7 @@ type Container struct {
 	// Effectively the version of API library used to create container
 	Version *grpc.Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
 	// OwnerID carries identifier of the container owner.
-	OwnerId *grpc1.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
+	OwnerId *grpc.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
 	// Nonce is a 16 byte UUID, used to avoid collisions of container id.
 	Nonce []byte `protobuf:"bytes,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
 	// BasicACL contains access control rules for owner, system, others groups and
@@ -43,7 +42,7 @@ type Container struct {
 	// Attributes define any immutable characteristics of container.
 	Attributes []*Container_Attribute `protobuf:"bytes,5,rep,name=attributes,proto3" json:"attributes,omitempty"`
 	// Placement policy for the object inside the container.
-	PlacementPolicy      *grpc2.PlacementPolicy `protobuf:"bytes,6,opt,name=placement_policy,json=placementPolicy,proto3" json:"placement_policy,omitempty"`
+	PlacementPolicy      *grpc1.PlacementPolicy `protobuf:"bytes,6,opt,name=placement_policy,json=placementPolicy,proto3" json:"placement_policy,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
 	XXX_unrecognized     []byte                 `json:"-"`
 	XXX_sizecache        int32                  `json:"-"`
@@ -89,7 +88,7 @@ func (m *Container) GetVersion() *grpc.Version {
 	return nil
 }
 
-func (m *Container) GetOwnerId() *grpc1.OwnerID {
+func (m *Container) GetOwnerId() *grpc.OwnerID {
 	if m != nil {
 		return m.OwnerId
 	}
@@ -117,7 +116,7 @@ func (m *Container) GetAttributes() []*Container_Attribute {
 	return nil
 }
 
-func (m *Container) GetPlacementPolicy() *grpc2.PlacementPolicy {
+func (m *Container) GetPlacementPolicy() *grpc1.PlacementPolicy {
 	if m != nil {
 		return m.PlacementPolicy
 	}
@@ -190,32 +189,31 @@ func init() {
 func init() { proto.RegisterFile("v2/container/grpc/types.proto", fileDescriptor_3bfd95a81c72c35c) }
 
 var fileDescriptor_3bfd95a81c72c35c = []byte{
-	// 398 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0xcd, 0xaa, 0x13, 0x31,
-	0x14, 0x76, 0x5a, 0xef, 0xcf, 0xe4, 0x2a, 0x5e, 0xa2, 0xe8, 0x30, 0x17, 0x4b, 0x75, 0x35, 0x9b,
-	0x26, 0x90, 0xeb, 0x4e, 0x5c, 0x54, 0x45, 0x2c, 0x88, 0x96, 0x08, 0x2e, 0xdc, 0x94, 0x34, 0x3d,
-	0x6d, 0x83, 0xd3, 0x24, 0x24, 0x69, 0xa4, 0x6f, 0xe2, 0x33, 0xf8, 0x24, 0x2e, 0x7d, 0x04, 0xa9,
-	0xcf, 0xe0, 0x5e, 0x26, 0xb5, 0x63, 0xa5, 0xee, 0xe6, 0x9c, 0xef, 0xfb, 0xce, 0xf9, 0xce, 0x37,
-	0x41, 0x0f, 0x23, 0xa3, 0xd2, 0xe8, 0x20, 0x94, 0x06, 0x47, 0x17, 0xce, 0x4a, 0x1a, 0x36, 0x16,
-	0x3c, 0xb1, 0xce, 0x04, 0x83, 0xef, 0x6a, 0x30, 0x64, 0xee, 0x49, 0x64, 0xa4, 0x65, 0x95, 0x65,
-	0x64, 0x54, 0x43, 0x58, 0x09, 0x7b, 0x24, 0x28, 0x8b, 0xc8, 0xa8, 0x83, 0xb9, 0x3f, 0x46, 0xae,
-	0x22, 0xa3, 0x1e, 0x5c, 0x54, 0x12, 0x8e, 0xc0, 0xc7, 0xbf, 0x3a, 0x28, 0x7f, 0xb1, 0x5f, 0x80,
-	0x9f, 0xa0, 0xb3, 0x08, 0xce, 0x2b, 0xa3, 0x8b, 0xac, 0x9f, 0x55, 0x17, 0xac, 0x24, 0x7f, 0x7d,
-	0xfc, 0x99, 0x41, 0x3e, 0xec, 0x18, 0x7c, 0x4f, 0xc5, 0x0c, 0x9d, 0x9b, 0xcf, 0x1a, 0xdc, 0x44,
-	0xcd, 0x8a, 0x4e, 0x92, 0x3d, 0x38, 0x90, 0x35, 0xa6, 0xc8, 0xbb, 0x06, 0x1f, 0xbd, 0xe4, 0x67,
-	0x89, 0x38, 0x9a, 0xe1, 0x7b, 0xe8, 0x44, 0x1b, 0x2d, 0xa1, 0xe8, 0xf6, 0xb3, 0xea, 0x16, 0xdf,
-	0x15, 0xf8, 0x0a, 0xe5, 0x53, 0xe1, 0x95, 0x9c, 0x08, 0x59, 0x17, 0x37, 0xfb, 0x59, 0x75, 0x9b,
-	0x9f, 0xa7, 0xc6, 0x50, 0xd6, 0xf8, 0x35, 0x42, 0x22, 0x04, 0xa7, 0xa6, 0xeb, 0x00, 0xbe, 0x38,
-	0xe9, 0x77, 0xab, 0x0b, 0x56, 0x91, 0xff, 0xe4, 0x44, 0xda, 0x83, 0xc8, 0x70, 0x2f, 0xe0, 0x07,
-	0x5a, 0xfc, 0x06, 0x5d, 0xda, 0x5a, 0x48, 0x58, 0x81, 0x0e, 0x13, 0x6b, 0x6a, 0x25, 0x37, 0xc5,
-	0x69, 0x32, 0xfe, 0xe8, 0x60, 0xde, 0x2e, 0x69, 0x32, 0xde, 0x33, 0xc7, 0x89, 0xc8, 0xef, 0xd8,
-	0x7f, 0x1b, 0xe5, 0x35, 0xca, 0xdb, 0x35, 0xf8, 0x12, 0x75, 0x3f, 0xc1, 0x26, 0xa5, 0x97, 0xf3,
-	0xe6, 0xb3, 0xb9, 0x34, 0x8a, 0x7a, 0x0d, 0x29, 0x9a, 0x9c, 0xef, 0x8a, 0xe7, 0xcb, 0x6f, 0xdb,
-	0x5e, 0xf6, 0x7d, 0xdb, 0xcb, 0x7e, 0x6c, 0x7b, 0xd9, 0x97, 0x9f, 0xbd, 0x1b, 0x1f, 0x9f, 0x2d,
-	0x54, 0x58, 0xae, 0xa7, 0x44, 0x9a, 0x15, 0xd5, 0xde, 0x4a, 0x39, 0x98, 0x41, 0xa4, 0x1a, 0xcc,
-	0xdc, 0x0f, 0x84, 0x55, 0x83, 0x85, 0xa1, 0x47, 0x4f, 0xe6, 0x69, 0x5b, 0x7e, 0xed, 0xdc, 0x7f,
-	0x0b, 0xe6, 0xd5, 0x7b, 0x32, 0x1c, 0x8f, 0x1a, 0xf3, 0x6d, 0x04, 0xd3, 0xd3, 0xf4, 0xa3, 0xaf,
-	0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x17, 0x73, 0x67, 0xd0, 0x71, 0x02, 0x00, 0x00,
+	// 383 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0x4d, 0xae, 0xd3, 0x30,
+	0x10, 0x26, 0x2d, 0xef, 0xb5, 0x71, 0x41, 0x54, 0x06, 0x41, 0x14, 0x44, 0x14, 0x58, 0x65, 0x53,
+	0x5b, 0xa4, 0x4b, 0xc4, 0xa2, 0x80, 0x10, 0x95, 0x10, 0x54, 0x46, 0x62, 0xc1, 0xa6, 0x72, 0xdc,
+	0x69, 0x6b, 0x91, 0xda, 0x56, 0xec, 0x06, 0xf5, 0x26, 0x9c, 0x81, 0x93, 0xb0, 0xe4, 0x08, 0xa8,
+	0xdc, 0x80, 0x13, 0xa0, 0x24, 0x4a, 0xe8, 0x53, 0xbb, 0xcb, 0xcc, 0xf7, 0x33, 0x33, 0x5f, 0x8c,
+	0x9e, 0x94, 0x29, 0x15, 0x5a, 0x39, 0x2e, 0x15, 0x14, 0x74, 0x53, 0x18, 0x41, 0xdd, 0xc1, 0x80,
+	0x25, 0xa6, 0xd0, 0x4e, 0xe3, 0xfb, 0x0a, 0x34, 0x59, 0x5b, 0x52, 0xa6, 0xa4, 0x63, 0x85, 0x61,
+	0x99, 0x52, 0x05, 0x6e, 0xc7, 0xcd, 0x99, 0x20, 0x0c, 0xca, 0x94, 0x16, 0xb0, 0xb6, 0x67, 0xc8,
+	0xb3, 0xbf, 0x3d, 0xe4, 0xbf, 0x6e, 0x3d, 0xf0, 0x73, 0x34, 0x28, 0xa1, 0xb0, 0x52, 0xab, 0xc0,
+	0x8b, 0xbd, 0x64, 0x94, 0x3e, 0x22, 0xff, 0x47, 0x55, 0x06, 0xe4, 0x73, 0x03, 0xb3, 0x96, 0x87,
+	0x53, 0x34, 0xd4, 0xdf, 0x14, 0x14, 0x4b, 0xb9, 0x0a, 0x7a, 0x97, 0x35, 0x1f, 0x2b, 0x7c, 0xfe,
+	0x86, 0x0d, 0x6a, 0xe2, 0x7c, 0x85, 0x1f, 0xa0, 0x2b, 0xa5, 0x95, 0x80, 0xa0, 0x1f, 0x7b, 0xc9,
+	0x1d, 0xd6, 0x14, 0xf8, 0x31, 0xf2, 0x33, 0x6e, 0xa5, 0x58, 0x72, 0x91, 0x07, 0xb7, 0x63, 0x2f,
+	0xb9, 0xcb, 0x86, 0x75, 0x63, 0x26, 0x72, 0xfc, 0x0e, 0x21, 0xee, 0x5c, 0x21, 0xb3, 0xbd, 0x03,
+	0x1b, 0x5c, 0xc5, 0xfd, 0x64, 0x94, 0x26, 0xe4, 0x42, 0x0e, 0xa4, 0xbb, 0x86, 0xcc, 0x5a, 0x01,
+	0x3b, 0xd1, 0xe2, 0xf7, 0x68, 0x6c, 0x72, 0x2e, 0x60, 0x07, 0xca, 0x2d, 0x8d, 0xce, 0xa5, 0x38,
+	0x04, 0xd7, 0xf5, 0xe2, 0x4f, 0x4f, 0xfc, 0x9a, 0x24, 0xc9, 0xa2, 0x65, 0x2e, 0x6a, 0x22, 0xbb,
+	0x67, 0x6e, 0x36, 0xc2, 0x29, 0xf2, 0xbb, 0x31, 0x78, 0x8c, 0xfa, 0x5f, 0xe1, 0x50, 0x47, 0xe7,
+	0xb3, 0xea, 0xb3, 0xba, 0xb4, 0xe4, 0xf9, 0x1e, 0xea, 0x68, 0x7c, 0xd6, 0x14, 0xaf, 0xb6, 0x3f,
+	0x8f, 0x91, 0xf7, 0xeb, 0x18, 0x79, 0xbf, 0x8f, 0x91, 0xf7, 0xfd, 0x4f, 0x74, 0xeb, 0xcb, 0xcb,
+	0x8d, 0x74, 0xdb, 0x7d, 0x46, 0x84, 0xde, 0x51, 0x65, 0x8d, 0x10, 0x93, 0x15, 0x94, 0x54, 0x81,
+	0x5e, 0xdb, 0x09, 0x37, 0x72, 0xb2, 0xd1, 0xf4, 0xec, 0x49, 0xbc, 0xe8, 0xca, 0x1f, 0xbd, 0x87,
+	0x1f, 0x40, 0xbf, 0xfd, 0x44, 0x66, 0x8b, 0x79, 0xb5, 0x7c, 0x17, 0x41, 0x76, 0x5d, 0xff, 0xe5,
+	0xe9, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x57, 0x93, 0x14, 0xb3, 0x51, 0x02, 0x00, 0x00,
 }
 
 func (m *Container) Marshal() (dAtA []byte, err error) {
@@ -517,7 +515,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.OwnerId == nil {
-				m.OwnerId = &grpc1.OwnerID{}
+				m.OwnerId = &grpc.OwnerID{}
 			}
 			if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -640,7 +638,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.PlacementPolicy == nil {
-				m.PlacementPolicy = &grpc2.PlacementPolicy{}
+				m.PlacementPolicy = &grpc1.PlacementPolicy{}
 			}
 			if err := m.PlacementPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
diff --git a/v2/object/grpc/service.pb.go b/v2/object/grpc/service.pb.go
index 4b3964d..2c8fc74 100644
--- a/v2/object/grpc/service.pb.go
+++ b/v2/object/grpc/service.pb.go
@@ -8,7 +8,7 @@ import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
 	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
+	grpc "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	grpc2 "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -323,7 +323,7 @@ type GetResponse_Body_Init struct {
 	// Object ID
 	ObjectId *grpc1.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
 	// Object signature
-	Signature *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
 	// Object header.
 	Header               *Header  `protobuf:"bytes,3,opt,name=header,proto3" json:"header,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -371,7 +371,7 @@ func (m *GetResponse_Body_Init) GetObjectId() *grpc1.ObjectID {
 	return nil
 }
 
-func (m *GetResponse_Body_Init) GetSignature() *grpc.Signature {
+func (m *GetResponse_Body_Init) GetSignature() *grpc1.Signature {
 	if m != nil {
 		return m.Signature
 	}
@@ -550,7 +550,7 @@ type PutRequest_Body_Init struct {
 	// Object ID, where available
 	ObjectId *grpc1.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
 	// Object signature, were available
-	Signature *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
 	// Header of the object to save in the system.
 	Header *Header `protobuf:"bytes,3,opt,name=header,proto3" json:"header,omitempty"`
 	// Number of the object copies to store within the RPC call.
@@ -602,7 +602,7 @@ func (m *PutRequest_Body_Init) GetObjectId() *grpc1.ObjectID {
 	return nil
 }
 
-func (m *PutRequest_Body_Init) GetSignature() *grpc.Signature {
+func (m *PutRequest_Body_Init) GetSignature() *grpc1.Signature {
 	if m != nil {
 		return m.Signature
 	}
@@ -1973,10 +1973,12 @@ type GetRangeHashRequest_Body struct {
 	// Carries the list of object payload range to calculate homomorphic hash.
 	Ranges []*Range `protobuf:"bytes,2,rep,name=ranges,proto3" json:"ranges,omitempty"`
 	// Carries binary salt to XOR object payload ranges before hash calculation.
-	Salt                 []byte   `protobuf:"bytes,3,opt,name=salt,proto3" json:"salt,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Salt []byte `protobuf:"bytes,3,opt,name=salt,proto3" json:"salt,omitempty"`
+	// Checksum algorithm type
+	Type                 grpc1.ChecksumType `protobuf:"varint,4,opt,name=type,proto3,enum=neo.fs.v2.refs.ChecksumType" json:"type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
 }
 
 func (m *GetRangeHashRequest_Body) Reset()         { *m = GetRangeHashRequest_Body{} }
@@ -2033,6 +2035,13 @@ func (m *GetRangeHashRequest_Body) GetSalt() []byte {
 	return nil
 }
 
+func (m *GetRangeHashRequest_Body) GetType() grpc1.ChecksumType {
+	if m != nil {
+		return m.Type
+	}
+	return grpc1.ChecksumType_CHECKSUM_TYPE_UNSPECIFIED
+}
+
 // Get hash of object's payload part
 type GetRangeHashResponse struct {
 	// Body of get range hash object response message.
@@ -2105,8 +2114,10 @@ func (m *GetRangeHashResponse) GetVerifyHeader() *grpc.ResponseVerificationHeade
 
 // Response body
 type GetRangeHashResponse_Body struct {
-	// Carries list of homomorphic hashes in a binary format.
-	HashList             [][]byte `protobuf:"bytes,1,rep,name=hash_list,json=hashList,proto3" json:"hash_list,omitempty"`
+	// Checksum algorithm type
+	Type grpc1.ChecksumType `protobuf:"varint,1,opt,name=type,proto3,enum=neo.fs.v2.refs.ChecksumType" json:"type,omitempty"`
+	// List of range hashes in a binary format.
+	HashList             [][]byte `protobuf:"bytes,2,rep,name=hash_list,json=hashList,proto3" json:"hash_list,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -2145,6 +2156,13 @@ func (m *GetRangeHashResponse_Body) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_GetRangeHashResponse_Body proto.InternalMessageInfo
 
+func (m *GetRangeHashResponse_Body) GetType() grpc1.ChecksumType {
+	if m != nil {
+		return m.Type
+	}
+	return grpc1.ChecksumType_CHECKSUM_TYPE_UNSPECIFIED
+}
+
 func (m *GetRangeHashResponse_Body) GetHashList() [][]byte {
 	if m != nil {
 		return m.HashList
@@ -2190,84 +2208,87 @@ func init() {
 func init() { proto.RegisterFile("v2/object/grpc/service.proto", fileDescriptor_1d7d92b1e85e5b48) }
 
 var fileDescriptor_1d7d92b1e85e5b48 = []byte{
-	// 1231 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x5d, 0x6f, 0x1b, 0x45,
-	0x17, 0xce, 0xae, 0x37, 0x4e, 0x7c, 0x6c, 0xe7, 0x8d, 0xa6, 0x51, 0x6b, 0x39, 0x1f, 0x6f, 0xba,
-	0x69, 0xd2, 0x88, 0x92, 0x75, 0x30, 0x2a, 0xa1, 0x29, 0x2d, 0x6a, 0x48, 0xd2, 0x58, 0x25, 0x6d,
-	0x58, 0x23, 0x2e, 0x90, 0x90, 0xb5, 0x59, 0x8f, 0xed, 0x05, 0x7b, 0xd7, 0xec, 0x8c, 0x8d, 0x7c,
-	0xc3, 0x25, 0x12, 0xbf, 0x80, 0x8a, 0x8b, 0x0a, 0x71, 0x59, 0xee, 0xf8, 0x01, 0x5c, 0xc3, 0x5d,
-	0xf9, 0x07, 0x28, 0xdc, 0x22, 0xf5, 0x17, 0x80, 0xd0, 0x7c, 0xac, 0xed, 0x8d, 0x3f, 0x95, 0xbb,
-	0xe5, 0x6e, 0x66, 0xfc, 0x9c, 0xe3, 0x39, 0xcf, 0x3c, 0x73, 0xe6, 0x9c, 0x85, 0x95, 0x76, 0x3e,
-	0xe7, 0x9d, 0x7f, 0x8e, 0x6d, 0x9a, 0xab, 0xfa, 0x4d, 0x3b, 0x47, 0xb0, 0xdf, 0x76, 0x6c, 0x6c,
-	0x34, 0x7d, 0x8f, 0x7a, 0x68, 0xd1, 0xc5, 0x9e, 0x51, 0x21, 0x46, 0x3b, 0x6f, 0x08, 0x50, 0x36,
-	0x7b, 0x09, 0x4f, 0x3b, 0x4d, 0x4c, 0x04, 0x3a, 0x9b, 0x69, 0xe7, 0x73, 0x3e, 0xae, 0x90, 0xc1,
-	0x5f, 0x96, 0xdb, 0xf9, 0xc0, 0xf3, 0xc0, 0x8f, 0xfa, 0x4b, 0x15, 0xe0, 0x31, 0xa6, 0x26, 0xfe,
-	0xb2, 0x85, 0x09, 0x45, 0x77, 0x41, 0x3b, 0xf7, 0xca, 0x9d, 0x8c, 0xb2, 0xae, 0x6c, 0x27, 0xf3,
-	0x37, 0x8d, 0xcb, 0x5b, 0x30, 0x7a, 0x58, 0xe3, 0xc0, 0x2b, 0x77, 0x4c, 0x0e, 0x47, 0x47, 0x90,
-	0x6c, 0x60, 0x6a, 0x95, 0x6a, 0xd8, 0x2a, 0x63, 0x3f, 0xa3, 0x72, 0xeb, 0x5b, 0x7d, 0xd6, 0x41,
-	0x64, 0xd2, 0xf6, 0x14, 0x53, 0xeb, 0x84, 0x63, 0x4d, 0x68, 0x74, 0xc7, 0xe8, 0x23, 0x48, 0xb7,
-	0xb1, 0xef, 0x54, 0x3a, 0x81, 0xa3, 0x18, 0x77, 0xf4, 0xe6, 0x68, 0x47, 0x9f, 0x30, 0xb8, 0x63,
-	0x5b, 0xd4, 0xf1, 0x5c, 0xe9, 0x30, 0x25, 0x5c, 0x88, 0x59, 0xf6, 0x09, 0x68, 0x6c, 0x9f, 0xe8,
-	0x2d, 0x98, 0xb3, 0xca, 0x65, 0x1f, 0x13, 0x22, 0x63, 0xbb, 0xd1, 0xe7, 0x94, 0xf1, 0x66, 0x3c,
-	0x12, 0x3f, 0x9b, 0x01, 0x0e, 0x2d, 0x42, 0xcc, 0xb7, 0xbe, 0xe2, 0xc1, 0xcc, 0x9b, 0x6c, 0xa8,
-	0xff, 0x13, 0x83, 0x24, 0x27, 0x80, 0x34, 0x3d, 0x97, 0x60, 0xf4, 0x4e, 0x88, 0x2d, 0x7d, 0x04,
-	0x5b, 0x02, 0xdc, 0x4f, 0xd7, 0xf1, 0x30, 0xba, 0x36, 0x87, 0x46, 0x29, 0x8c, 0x47, 0xf0, 0x65,
-	0x0e, 0xe7, 0x6b, 0x67, 0x8c, 0xa7, 0x89, 0x84, 0x7d, 0xaf, 0x4a, 0xc6, 0x1e, 0x80, 0xe6, 0xb8,
-	0x0e, 0x95, 0xc1, 0xdd, 0x9e, 0x1c, 0x9c, 0x51, 0x70, 0x1d, 0x7a, 0x32, 0x63, 0x72, 0x33, 0x74,
-	0x1d, 0x66, 0xed, 0x5a, 0xcb, 0xfd, 0x82, 0x47, 0x97, 0x3a, 0x99, 0x31, 0xc5, 0x34, 0xfb, 0x93,
-	0x02, 0x1a, 0x03, 0xa2, 0xbb, 0x90, 0x10, 0x8e, 0x4a, 0x4e, 0x59, 0xfe, 0x49, 0xe6, 0xf2, 0x99,
-	0x3c, 0xe3, 0x80, 0xc2, 0xa1, 0x39, 0x2f, 0xa0, 0x85, 0x32, 0xda, 0x87, 0x04, 0x71, 0xaa, 0xae,
-	0x45, 0x5b, 0x3e, 0x96, 0xcc, 0xad, 0x0c, 0x89, 0xb7, 0x18, 0x60, 0xcc, 0x1e, 0x1c, 0xed, 0x42,
-	0x3c, 0x44, 0x54, 0x66, 0x30, 0x28, 0xc9, 0x89, 0xc4, 0x1d, 0xa4, 0x21, 0x29, 0x37, 0xd9, 0xb4,
-	0x7c, 0xaa, 0xbf, 0xd0, 0x00, 0xce, 0x5a, 0xd3, 0xdf, 0x96, 0x1e, 0x36, 0x1a, 0xb7, 0xe5, 0x97,
-	0xe0, 0xf0, 0xdf, 0x0b, 0x1d, 0xfe, 0xd6, 0xc4, 0xc8, 0xa6, 0x3b, 0xfb, 0x57, 0x51, 0x3a, 0x7b,
-	0xb4, 0x01, 0x69, 0xdb, 0x6b, 0x3a, 0x98, 0x94, 0xdc, 0x56, 0xe3, 0x1c, 0xfb, 0x19, 0x6d, 0x5d,
-	0xd9, 0x4e, 0x9b, 0x29, 0xb1, 0xf8, 0x94, 0xaf, 0x5d, 0x16, 0xc8, 0x0f, 0x2a, 0x24, 0x39, 0x35,
-	0xd3, 0x66, 0x88, 0x3e, 0x70, 0x54, 0x32, 0xc4, 0x03, 0xa9, 0x91, 0xab, 0x1d, 0xa2, 0xfe, 0x42,
-	0x85, 0xf4, 0x21, 0xae, 0x63, 0x8a, 0x83, 0x6b, 0xf4, 0x6e, 0x88, 0xa4, 0x5b, 0x83, 0x24, 0x85,
-	0xe0, 0xd1, 0xb8, 0x49, 0xf7, 0xae, 0xfc, 0xee, 0xe8, 0xaf, 0x15, 0x58, 0x08, 0x22, 0x96, 0x32,
-	0xba, 0x17, 0x62, 0x68, 0x73, 0x34, 0x43, 0xd1, 0x52, 0x52, 0x5c, 0x90, 0xa4, 0xff, 0xa6, 0x42,
-	0x92, 0x2d, 0x05, 0x82, 0x98, 0x78, 0x6b, 0xfa, 0xc0, 0xd1, 0x90, 0x43, 0xed, 0xea, 0x65, 0xc8,
-	0x32, 0x24, 0x1a, 0x96, 0xe3, 0x96, 0x3c, 0xb7, 0xde, 0x91, 0xc5, 0xc8, 0x3c, 0x5b, 0x78, 0xe6,
-	0xd6, 0x3b, 0x41, 0x8d, 0x12, 0xeb, 0xd5, 0x28, 0x7f, 0xa9, 0x90, 0x12, 0xf4, 0x48, 0xed, 0xec,
-	0x85, 0xc8, 0xdc, 0x18, 0x45, 0x66, 0xb4, 0x94, 0xf3, 0x8d, 0x22, 0x09, 0xcd, 0x77, 0xd3, 0xba,
-	0x32, 0x3e, 0xad, 0x9f, 0xcc, 0x74, 0x13, 0xfb, 0x01, 0xa4, 0x48, 0xcd, 0xf3, 0x69, 0x38, 0xb2,
-	0xd5, 0x41, 0xcb, 0x22, 0x43, 0x75, 0xcd, 0x93, 0xa4, 0x37, 0x3d, 0x88, 0x83, 0xc6, 0xac, 0xf5,
-	0xbf, 0x63, 0x90, 0x2e, 0x62, 0xcb, 0xb7, 0x6b, 0x53, 0x67, 0xb3, 0x10, 0x3c, 0x1a, 0xf2, 0xfd,
-	0x2e, 0xa8, 0x0b, 0x1e, 0x42, 0xca, 0xf6, 0x5c, 0x6a, 0x39, 0x2e, 0xf6, 0x7b, 0x69, 0x7f, 0xf9,
-	0xb2, 0x88, 0x3f, 0x08, 0x30, 0x85, 0x43, 0x33, 0xd9, 0x35, 0x28, 0x94, 0x51, 0x06, 0xe6, 0xda,
-	0xd8, 0x27, 0x8e, 0xe7, 0xf2, 0xf0, 0xd2, 0x66, 0x30, 0x45, 0x47, 0x30, 0x57, 0x71, 0xea, 0x14,
-	0xfb, 0x24, 0x13, 0x5b, 0x8f, 0x6d, 0x27, 0xf3, 0x77, 0xa6, 0x61, 0xce, 0x38, 0xe6, 0x36, 0x66,
-	0x60, 0x9b, 0x75, 0x21, 0x2e, 0x96, 0xd0, 0x3e, 0x40, 0xc3, 0xa2, 0x76, 0xad, 0xc4, 0xda, 0x1d,
-	0xbe, 0xd1, 0x85, 0xd0, 0x46, 0xa5, 0xcf, 0x53, 0x86, 0xf9, 0xb8, 0xd3, 0xc4, 0x66, 0xa2, 0x11,
-	0x0c, 0x11, 0x02, 0xcd, 0xb5, 0x1a, 0xa2, 0xc6, 0x48, 0x98, 0x7c, 0x8c, 0x96, 0x60, 0xb6, 0x6d,
-	0xd5, 0x5b, 0x98, 0xd3, 0x99, 0x30, 0xc5, 0x44, 0xff, 0x51, 0x85, 0x85, 0x60, 0x5b, 0xd3, 0x26,
-	0xeb, 0x30, 0x3e, 0x2a, 0x57, 0xae, 0xef, 0x45, 0x73, 0xca, 0xa5, 0xba, 0x43, 0x58, 0x75, 0x18,
-	0x1b, 0xfb, 0xe8, 0xc7, 0x9d, 0xf2, 0x87, 0x0e, 0xa1, 0xfa, 0x1e, 0xcc, 0x9a, 0x96, 0x5b, 0xc5,
-	0xe8, 0x3a, 0xc4, 0xbd, 0x4a, 0x85, 0x60, 0x51, 0x58, 0x6a, 0xa6, 0x9c, 0xb1, 0xf5, 0x3a, 0x76,
-	0xab, 0xb4, 0xc6, 0x43, 0xd6, 0x4c, 0x39, 0xd3, 0x7f, 0x57, 0xe1, 0x7f, 0xac, 0xcd, 0x60, 0xc6,
-	0xc1, 0xfd, 0xda, 0x0f, 0xd1, 0xbb, 0x35, 0xbc, 0x2f, 0xe9, 0x33, 0xf8, 0xcf, 0x3f, 0x10, 0x3b,
-	0x30, 0xeb, 0xb3, 0x78, 0x65, 0x38, 0x37, 0x06, 0x19, 0x11, 0x74, 0x08, 0x94, 0xfe, 0xad, 0x0a,
-	0x8b, 0x3d, 0x8a, 0xa4, 0x66, 0xef, 0x87, 0x48, 0xbd, 0x3d, 0x8e, 0xd4, 0x68, 0xa9, 0x76, 0x45,
-	0xf2, 0xba, 0x14, 0xb4, 0x24, 0x2c, 0xc2, 0x94, 0x6c, 0x48, 0xf4, 0xd7, 0x2a, 0x5c, 0x0b, 0x22,
-	0x3b, 0xb1, 0x48, 0x37, 0x87, 0x3f, 0x0c, 0xd1, 0xf1, 0xc6, 0x68, 0x3a, 0xfa, 0x8c, 0xa2, 0xa1,
-	0xb3, 0xaf, 0xaf, 0xae, 0xb3, 0x1c, 0xc4, 0xb9, 0x82, 0x48, 0x46, 0xe5, 0xf7, 0x7e, 0xa4, 0xd0,
-	0x24, 0x8c, 0x65, 0x51, 0x62, 0xd5, 0x29, 0xdf, 0x75, 0xca, 0xe4, 0x63, 0xfd, 0xb9, 0x0a, 0x4b,
-	0x61, 0xf2, 0xa4, 0x02, 0xdf, 0x0f, 0x51, 0x7e, 0x67, 0x12, 0xe5, 0xd1, 0x52, 0xe1, 0x86, 0x64,
-	0x7d, 0x19, 0x12, 0x35, 0x8b, 0xd4, 0x7a, 0xd9, 0x33, 0x65, 0xce, 0xb3, 0x05, 0x96, 0x25, 0xf3,
-	0x3f, 0x6b, 0x90, 0x16, 0xa9, 0xb3, 0x28, 0xfc, 0xa3, 0x43, 0x88, 0x3d, 0xc6, 0x14, 0xad, 0x8c,
-	0xfb, 0x0c, 0x97, 0x5d, 0x1d, 0xfb, 0x65, 0x66, 0x57, 0x61, 0x5e, 0xce, 0x5a, 0x43, 0xbd, 0xf4,
-	0x9a, 0xf8, 0x61, 0x5e, 0xfa, 0x5a, 0xd3, 0x6d, 0x05, 0x3d, 0x81, 0xb8, 0x68, 0x32, 0xd0, 0xff,
-	0x27, 0x34, 0x68, 0xd9, 0xf5, 0x49, 0xfd, 0x09, 0x3a, 0x02, 0x8d, 0x31, 0x83, 0x56, 0xc7, 0x96,
-	0xf6, 0xd9, 0xb5, 0xf1, 0xc5, 0x2a, 0x3a, 0x85, 0xb8, 0x78, 0x4b, 0x87, 0xed, 0x29, 0x54, 0x2c,
-	0x0c, 0xdb, 0x53, 0xf8, 0x19, 0xde, 0x55, 0x50, 0x11, 0xe6, 0x03, 0x91, 0xa1, 0x9b, 0x13, 0xdf,
-	0x95, 0xac, 0x3e, 0x39, 0x4b, 0xee, 0x2a, 0xe8, 0x33, 0x48, 0xf5, 0x2b, 0x17, 0x6d, 0x4e, 0x95,
-	0x4c, 0xb2, 0x5b, 0xd3, 0x5d, 0x80, 0x83, 0xd2, 0xaf, 0x17, 0x6b, 0xca, 0xab, 0x8b, 0x35, 0xe5,
-	0x8f, 0x8b, 0x35, 0xe5, 0xf9, 0x9f, 0x6b, 0x33, 0x9f, 0xee, 0x55, 0x1d, 0x5a, 0x6b, 0x9d, 0x1b,
-	0xb6, 0xd7, 0xc8, 0xb9, 0xa4, 0x69, 0xdb, 0x3b, 0x65, 0xdc, 0xce, 0xb9, 0xd8, 0xab, 0x90, 0x1d,
-	0xab, 0xe9, 0xec, 0x54, 0xbd, 0x5c, 0xf8, 0x33, 0xf2, 0x7d, 0x31, 0x7e, 0xa9, 0x5e, 0x7b, 0x8a,
-	0xbd, 0xe3, 0xa2, 0xf1, 0xe8, 0xac, 0xc0, 0xfe, 0x55, 0x48, 0xf1, 0x3c, 0xce, 0xbf, 0x13, 0xbf,
-	0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x11, 0xd3, 0xc8, 0xed, 0xac, 0x16, 0x00, 0x00,
+	// 1267 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xdd, 0x6e, 0x1b, 0xc5,
+	0x17, 0xcf, 0xae, 0x37, 0x6e, 0x7c, 0x6c, 0xe7, 0x1f, 0x4d, 0xa3, 0xd6, 0x7f, 0xe7, 0x83, 0x74,
+	0xdb, 0xa4, 0x11, 0x25, 0xeb, 0x60, 0x54, 0x42, 0x5b, 0x5a, 0xd4, 0x90, 0xa4, 0xb1, 0x4a, 0xda,
+	0xb0, 0x06, 0x2e, 0x90, 0x90, 0xb5, 0x59, 0x8f, 0xed, 0xa5, 0xf6, 0xae, 0xd9, 0x19, 0x1b, 0xf9,
+	0x05, 0x90, 0x78, 0x02, 0x90, 0x90, 0x10, 0xea, 0x15, 0xea, 0x15, 0xe2, 0x96, 0x17, 0x00, 0x24,
+	0x24, 0x78, 0x03, 0x14, 0x6e, 0x91, 0x78, 0x00, 0x84, 0x84, 0xe6, 0x63, 0x6d, 0xaf, 0xbf, 0x95,
+	0xbb, 0xe5, 0x6e, 0x66, 0xf6, 0x77, 0xce, 0xce, 0xf9, 0xcd, 0x6f, 0xce, 0x9c, 0x19, 0x58, 0x6d,
+	0xe7, 0x73, 0xde, 0xd9, 0xc7, 0xd8, 0xa6, 0xb9, 0xaa, 0xdf, 0xb4, 0x73, 0x04, 0xfb, 0x6d, 0xc7,
+	0xc6, 0x46, 0xd3, 0xf7, 0xa8, 0x87, 0x96, 0x5c, 0xec, 0x19, 0x15, 0x62, 0xb4, 0xf3, 0x86, 0x00,
+	0x65, 0xb3, 0x03, 0x78, 0xda, 0x69, 0x62, 0x22, 0xd0, 0xd9, 0x4c, 0x3b, 0x9f, 0xf3, 0x71, 0x85,
+	0x0c, 0x7f, 0x59, 0x69, 0xe7, 0x73, 0x04, 0x13, 0xe2, 0x78, 0xee, 0xd0, 0x47, 0xfd, 0x85, 0x0a,
+	0xf0, 0x08, 0x53, 0x13, 0x7f, 0xd2, 0xc2, 0x84, 0xa2, 0xdb, 0xa0, 0x9d, 0x79, 0xe5, 0x4e, 0x46,
+	0xd9, 0x50, 0xb6, 0x93, 0xf9, 0x6b, 0xc6, 0xe0, 0x14, 0x8c, 0x1e, 0xd6, 0xd8, 0xf7, 0xca, 0x1d,
+	0x93, 0xc3, 0xd1, 0x21, 0x24, 0x1b, 0x98, 0x5a, 0xa5, 0x1a, 0xb6, 0xca, 0xd8, 0xcf, 0xa8, 0xdc,
+	0xfa, 0x46, 0x9f, 0xb5, 0xfc, 0xbf, 0x21, 0x6d, 0x4f, 0x30, 0xb5, 0x8e, 0x39, 0xd6, 0x84, 0x46,
+	0xb7, 0x8d, 0xde, 0x85, 0x74, 0x1b, 0xfb, 0x4e, 0xa5, 0x13, 0x38, 0x8a, 0x71, 0x47, 0xaf, 0x8c,
+	0x77, 0xf4, 0x01, 0x83, 0x3b, 0xb6, 0x45, 0x1d, 0xcf, 0x95, 0x0e, 0x53, 0xc2, 0x85, 0xe8, 0x65,
+	0x1f, 0x83, 0xc6, 0xe6, 0x89, 0x5e, 0x85, 0x4b, 0x56, 0xb9, 0xec, 0x63, 0x42, 0x64, 0x6c, 0x57,
+	0xfb, 0x9c, 0x32, 0xde, 0x8c, 0x87, 0xe2, 0xb3, 0x19, 0xe0, 0xd0, 0x12, 0xc4, 0x7c, 0xeb, 0x53,
+	0x1e, 0xcc, 0x82, 0xc9, 0x9a, 0xfa, 0xdf, 0x31, 0x48, 0x72, 0x02, 0x48, 0xd3, 0x73, 0x09, 0x46,
+	0xaf, 0x87, 0xd8, 0xd2, 0xc7, 0xb0, 0x25, 0xc0, 0xfd, 0x74, 0x1d, 0x8d, 0xa2, 0x6b, 0x73, 0x64,
+	0x94, 0xc2, 0x78, 0x0c, 0x5f, 0xe6, 0x68, 0xbe, 0x76, 0x26, 0x78, 0x9a, 0x4a, 0xd8, 0x17, 0xaa,
+	0x64, 0xec, 0x3e, 0x68, 0x8e, 0xeb, 0x50, 0x19, 0xdc, 0xcd, 0xe9, 0xc1, 0x19, 0x05, 0xd7, 0xa1,
+	0xc7, 0x73, 0x26, 0x37, 0x43, 0x57, 0x60, 0xde, 0xae, 0xb5, 0xdc, 0x67, 0x3c, 0xba, 0xd4, 0xf1,
+	0x9c, 0x29, 0xba, 0xd9, 0x6f, 0x15, 0xd0, 0x18, 0x10, 0xdd, 0x86, 0x84, 0x70, 0x54, 0x72, 0xca,
+	0xf2, 0x27, 0x99, 0xc1, 0x35, 0x79, 0xca, 0x01, 0x85, 0x03, 0x73, 0x41, 0x40, 0x0b, 0x65, 0xb4,
+	0x07, 0x09, 0xe2, 0x54, 0x5d, 0x8b, 0xb6, 0x7c, 0x2c, 0x99, 0xfb, 0xff, 0xa0, 0x59, 0x31, 0x00,
+	0x98, 0x3d, 0x2c, 0xda, 0x85, 0x78, 0x88, 0xa5, 0xcc, 0x70, 0x44, 0x92, 0x10, 0x89, 0xdb, 0x4f,
+	0x43, 0x52, 0xce, 0xb0, 0x69, 0xf9, 0x54, 0xff, 0x4a, 0x03, 0x38, 0x6d, 0xcd, 0xbe, 0x55, 0x7a,
+	0xd8, 0x68, 0x6c, 0x95, 0x1f, 0x82, 0x95, 0x7f, 0x33, 0xb4, 0xf2, 0x5b, 0x53, 0x23, 0x9b, 0x6d,
+	0xe1, 0x7f, 0x89, 0xcc, 0xc2, 0xa3, 0xeb, 0x90, 0xb6, 0xbd, 0xa6, 0x83, 0x49, 0xc9, 0x6d, 0x35,
+	0xce, 0xb0, 0x9f, 0xd1, 0x36, 0x94, 0xed, 0xb4, 0x99, 0x12, 0x83, 0x4f, 0xf8, 0xd8, 0xa0, 0x3a,
+	0xbe, 0x51, 0x21, 0xc9, 0x79, 0x99, 0x35, 0x37, 0xf4, 0x81, 0xa3, 0x92, 0x1b, 0xee, 0x4b, 0x81,
+	0x5c, 0x6c, 0x05, 0xf5, 0xaf, 0x55, 0x48, 0x1f, 0xe0, 0x3a, 0xa6, 0x38, 0xd8, 0x43, 0x6f, 0x84,
+	0x48, 0xba, 0x31, 0x4c, 0x52, 0x08, 0x1e, 0x8d, 0x6d, 0x74, 0xe7, 0xc2, 0x27, 0x8e, 0xfe, 0x97,
+	0x02, 0x8b, 0x41, 0xc4, 0x52, 0x46, 0x77, 0x42, 0x0c, 0x6d, 0x8e, 0x67, 0x28, 0x5a, 0x4a, 0x8a,
+	0x0b, 0x92, 0xf4, 0x9f, 0x54, 0x48, 0xb2, 0xa1, 0x40, 0x10, 0x53, 0x77, 0x4d, 0x1f, 0x38, 0x1a,
+	0x72, 0xa8, 0x5d, 0xbc, 0x00, 0x59, 0x81, 0x44, 0xc3, 0x72, 0xdc, 0x92, 0xe7, 0xd6, 0x3b, 0xb2,
+	0x0c, 0x59, 0x60, 0x03, 0x4f, 0xdd, 0x7a, 0x27, 0xa8, 0x4e, 0x62, 0xbd, 0xea, 0xe4, 0x4f, 0x15,
+	0x52, 0x82, 0x1e, 0xa9, 0x9d, 0xbd, 0x10, 0x99, 0xd7, 0xc7, 0x91, 0x19, 0x2d, 0xe5, 0x7c, 0xa6,
+	0x48, 0x42, 0xf3, 0xdd, 0xb4, 0xae, 0x4c, 0x4e, 0xeb, 0xc7, 0x73, 0xdd, 0xc4, 0xbe, 0x0f, 0x29,
+	0x52, 0xf3, 0x7c, 0x1a, 0x8e, 0x6c, 0x6d, 0xd8, 0xb2, 0xc8, 0x50, 0x5d, 0xf3, 0x24, 0xe9, 0x75,
+	0xf7, 0xe3, 0xa0, 0x31, 0x6b, 0xfd, 0x9f, 0x18, 0xa4, 0x8b, 0xd8, 0xf2, 0xed, 0xda, 0xcc, 0xd9,
+	0x2c, 0x04, 0x8f, 0x86, 0x7c, 0xbb, 0xe5, 0xe0, 0x03, 0x48, 0xd9, 0x9e, 0x4b, 0x2d, 0xc7, 0xc5,
+	0x7e, 0x2f, 0xed, 0xaf, 0x0c, 0x8a, 0xf8, 0xed, 0x00, 0x53, 0x38, 0x30, 0x93, 0x5d, 0x83, 0x42,
+	0x19, 0x65, 0xe0, 0x52, 0x1b, 0xfb, 0xec, 0xdf, 0x3c, 0xbc, 0xb4, 0x19, 0x74, 0xd1, 0x21, 0x5c,
+	0xaa, 0x38, 0x75, 0x8a, 0x7d, 0x92, 0x89, 0x6d, 0xc4, 0xb6, 0x93, 0xf9, 0x5b, 0xb3, 0x30, 0x67,
+	0x1c, 0x71, 0x1b, 0x33, 0xb0, 0xcd, 0xba, 0x10, 0x17, 0x43, 0xe8, 0x2e, 0x40, 0xc3, 0xa2, 0x76,
+	0xad, 0xc4, 0x2e, 0x3a, 0x7c, 0xa2, 0x8b, 0xa1, 0x89, 0x4a, 0x9f, 0x27, 0x0c, 0xf3, 0x5e, 0xa7,
+	0x89, 0xcd, 0x44, 0x23, 0x68, 0x22, 0x04, 0x9a, 0x6b, 0x35, 0x44, 0x81, 0x91, 0x30, 0x79, 0x1b,
+	0x2d, 0xc3, 0x7c, 0xdb, 0xaa, 0xb7, 0x30, 0xa7, 0x33, 0x61, 0x8a, 0x8e, 0xfe, 0x5c, 0x85, 0xc5,
+	0x60, 0x5a, 0xb3, 0x26, 0xeb, 0x30, 0x3e, 0x2a, 0x5b, 0xae, 0xef, 0x44, 0x73, 0xca, 0xa5, 0xba,
+	0x43, 0x58, 0x69, 0x18, 0x9b, 0x78, 0xe8, 0xc7, 0x9d, 0xf2, 0x3b, 0x0e, 0xa1, 0xfa, 0x1e, 0xcc,
+	0x9b, 0x96, 0x5b, 0xc5, 0xe8, 0x0a, 0xc4, 0xbd, 0x4a, 0x85, 0x60, 0x51, 0x55, 0x6a, 0xa6, 0xec,
+	0xb1, 0xf1, 0x3a, 0x76, 0xab, 0xb4, 0xc6, 0x43, 0xd6, 0x4c, 0xd9, 0xd3, 0x7f, 0x53, 0xe1, 0x7f,
+	0xec, 0x82, 0xc1, 0x8c, 0x83, 0xfd, 0x75, 0x37, 0x44, 0xef, 0xd6, 0xe8, 0x1b, 0x49, 0x9f, 0xc1,
+	0x7f, 0xfe, 0x80, 0xd8, 0x81, 0x79, 0x9f, 0xc5, 0x2b, 0xc3, 0xb9, 0x3a, 0xcc, 0x88, 0xa0, 0x43,
+	0xa0, 0xf4, 0xcf, 0x55, 0x58, 0xea, 0x51, 0x24, 0x35, 0x7b, 0x2f, 0x44, 0xea, 0xcd, 0x49, 0xa4,
+	0x46, 0x4b, 0xb5, 0xab, 0x92, 0xd7, 0xe5, 0xe0, 0x3e, 0xc2, 0x22, 0x4c, 0xc9, 0xdb, 0x88, 0xfe,
+	0x3c, 0x06, 0x97, 0x83, 0xc8, 0x8e, 0x2d, 0xd2, 0xcd, 0xe1, 0x0f, 0x42, 0x74, 0xbc, 0x3c, 0x9e,
+	0x8e, 0x3e, 0xa3, 0x68, 0xe8, 0xec, 0x3b, 0xe5, 0xe2, 0x42, 0xcb, 0x41, 0x9c, 0x4b, 0x88, 0x64,
+	0x54, 0xbe, 0xf1, 0xc7, 0x2a, 0x4d, 0xc2, 0x58, 0x1a, 0x25, 0x56, 0x9d, 0xf2, 0x69, 0xa7, 0x4c,
+	0xde, 0x46, 0xbb, 0xa0, 0xf1, 0x84, 0xac, 0xf1, 0x84, 0xbc, 0x3a, 0x74, 0x72, 0xd4, 0xb0, 0xfd,
+	0x8c, 0xb4, 0x1a, 0x3c, 0x23, 0x73, 0xa4, 0xfe, 0xb3, 0x0a, 0xcb, 0x61, 0xbe, 0xa5, 0x68, 0xdf,
+	0x0a, 0xad, 0xd2, 0xad, 0x69, 0xab, 0x14, 0x2d, 0xe1, 0xbe, 0x2f, 0xd7, 0x29, 0xe0, 0x4b, 0x99,
+	0x95, 0x2f, 0x56, 0x30, 0xd6, 0x2c, 0x52, 0x13, 0x29, 0x9a, 0xad, 0x54, 0xca, 0x5c, 0x60, 0x03,
+	0x2c, 0x15, 0xe7, 0xbf, 0xd7, 0x20, 0x2d, 0xf2, 0x73, 0x51, 0x3c, 0x33, 0xa2, 0x03, 0x88, 0x3d,
+	0xc2, 0x14, 0xad, 0x4e, 0x7a, 0xe5, 0xcb, 0xae, 0x4d, 0x7c, 0xf8, 0xd9, 0x55, 0x98, 0x97, 0xd3,
+	0xd6, 0x48, 0x2f, 0xbd, 0x67, 0x82, 0x51, 0x5e, 0xfa, 0xee, 0xbf, 0xdb, 0x0a, 0x7a, 0x0c, 0x71,
+	0x71, 0x93, 0x41, 0x2f, 0x4d, 0xb9, 0x05, 0x66, 0x37, 0xa6, 0x5d, 0x82, 0xd0, 0x21, 0x68, 0x8c,
+	0x4b, 0xb4, 0x36, 0xf1, 0xfe, 0x90, 0x5d, 0x9f, 0x5c, 0x11, 0xa3, 0x13, 0x88, 0x8b, 0x03, 0x7b,
+	0xd4, 0x9c, 0x42, 0x15, 0xc9, 0xa8, 0x39, 0x85, 0xcf, 0xfa, 0x5d, 0x05, 0x15, 0x61, 0x21, 0x90,
+	0x25, 0xba, 0x36, 0xf5, 0xf0, 0xca, 0xea, 0xd3, 0x53, 0xf1, 0xae, 0x82, 0x3e, 0x82, 0x54, 0xbf,
+	0xd6, 0xd1, 0xe6, 0x4c, 0x19, 0x2b, 0xbb, 0x35, 0xdb, 0x96, 0xd9, 0x2f, 0xfd, 0x78, 0xbe, 0xae,
+	0xfc, 0x7a, 0xbe, 0xae, 0xfc, 0x7e, 0xbe, 0xae, 0x7c, 0xf9, 0xc7, 0xfa, 0xdc, 0x87, 0x7b, 0x55,
+	0x87, 0xd6, 0x5a, 0x67, 0x86, 0xed, 0x35, 0x72, 0x2e, 0x69, 0xda, 0xf6, 0x4e, 0x19, 0xb7, 0x73,
+	0x2e, 0xf6, 0x2a, 0x64, 0xc7, 0x6a, 0x3a, 0x3b, 0x55, 0x2f, 0x17, 0x7e, 0xa5, 0xbe, 0x27, 0xda,
+	0x2f, 0xd4, 0xcb, 0x4f, 0xb0, 0x77, 0x54, 0x34, 0x1e, 0x9e, 0x16, 0xd8, 0x5f, 0x85, 0x14, 0xcf,
+	0xe2, 0xfc, 0x19, 0xfa, 0xb5, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x71, 0xb6, 0x54, 0x0b,
+	0x17, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -4410,6 +4431,11 @@ func (m *GetRangeHashRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.Type != 0 {
+		i = encodeVarintService(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x20
+	}
 	if len(m.Salt) > 0 {
 		i -= len(m.Salt)
 		copy(dAtA[i:], m.Salt)
@@ -4539,9 +4565,14 @@ func (m *GetRangeHashResponse_Body) MarshalToSizedBuffer(dAtA []byte) (int, erro
 			copy(dAtA[i:], m.HashList[iNdEx])
 			i = encodeVarintService(dAtA, i, uint64(len(m.HashList[iNdEx])))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
 		}
 	}
+	if m.Type != 0 {
+		i = encodeVarintService(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x8
+	}
 	return len(dAtA) - i, nil
 }
 
@@ -5261,6 +5292,9 @@ func (m *GetRangeHashRequest_Body) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovService(uint64(l))
 	}
+	if m.Type != 0 {
+		n += 1 + sovService(uint64(m.Type))
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -5297,6 +5331,9 @@ func (m *GetRangeHashResponse_Body) Size() (n int) {
 	}
 	var l int
 	_ = l
+	if m.Type != 0 {
+		n += 1 + sovService(uint64(m.Type))
+	}
 	if len(m.HashList) > 0 {
 		for _, b := range m.HashList {
 			l = len(b)
@@ -5966,7 +6003,7 @@ func (m *GetResponse_Body_Init) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Signature == nil {
-				m.Signature = &grpc.Signature{}
+				m.Signature = &grpc1.Signature{}
 			}
 			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -6412,7 +6449,7 @@ func (m *PutRequest_Body_Init) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Signature == nil {
-				m.Signature = &grpc.Signature{}
+				m.Signature = &grpc1.Signature{}
 			}
 			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -9413,6 +9450,25 @@ func (m *GetRangeHashRequest_Body) Unmarshal(dAtA []byte) error {
 				m.Salt = []byte{}
 			}
 			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowService
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= grpc1.ChecksumType(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipService(dAtA[iNdEx:])
@@ -9630,6 +9686,25 @@ func (m *GetRangeHashResponse_Body) Unmarshal(dAtA []byte) error {
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowService
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= grpc1.ChecksumType(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field HashList", wireType)
 			}
diff --git a/v2/object/grpc/types.pb.go b/v2/object/grpc/types.pb.go
index e616358..646ee2d 100644
--- a/v2/object/grpc/types.pb.go
+++ b/v2/object/grpc/types.pb.go
@@ -6,8 +6,8 @@ package object
 import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
+	grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
+	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -91,7 +91,7 @@ type ShortHeader struct {
 	// Epoch when the object was created
 	CreationEpoch uint64 `protobuf:"varint,2,opt,name=creation_epoch,json=creationEpoch,proto3" json:"creation_epoch,omitempty"`
 	// Object's owner
-	OwnerId *grpc1.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
+	OwnerId *grpc.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
 	// Type of the object payload content
 	ObjectType ObjectType `protobuf:"varint,4,opt,name=object_type,json=objectType,proto3,enum=neo.fs.v2.object.ObjectType" json:"object_type,omitempty"`
 	// Size of payload in bytes.
@@ -149,7 +149,7 @@ func (m *ShortHeader) GetCreationEpoch() uint64 {
 	return 0
 }
 
-func (m *ShortHeader) GetOwnerId() *grpc1.OwnerID {
+func (m *ShortHeader) GetOwnerId() *grpc.OwnerID {
 	if m != nil {
 		return m.OwnerId
 	}
@@ -176,23 +176,23 @@ type Header struct {
 	// Effectively the version of API library used to create particular object
 	Version *grpc.Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
 	// Object's container
-	ContainerId *grpc1.ContainerID `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
+	ContainerId *grpc.ContainerID `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
 	// Object's owner
-	OwnerId *grpc1.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
+	OwnerId *grpc.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
 	// Object creation Epoch
 	CreationEpoch uint64 `protobuf:"varint,4,opt,name=creation_epoch,json=creationEpoch,proto3" json:"creation_epoch,omitempty"`
 	// Size of payload in bytes.
 	// 0xFFFFFFFFFFFFFFFF means `payload_length` is unknown
 	PayloadLength uint64 `protobuf:"varint,5,opt,name=payload_length,json=payloadLength,proto3" json:"payload_length,omitempty"`
 	// Hash of payload bytes
-	PayloadHash []byte `protobuf:"bytes,6,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"`
+	PayloadHash *grpc.Checksum `protobuf:"bytes,6,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"`
 	// Special object type
 	ObjectType ObjectType `protobuf:"varint,7,opt,name=object_type,json=objectType,proto3,enum=neo.fs.v2.object.ObjectType" json:"object_type,omitempty"`
 	// Homomorphic hash of the object payload.
-	HomomorphicHash []byte `protobuf:"bytes,8,opt,name=homomorphic_hash,json=homomorphicHash,proto3" json:"homomorphic_hash,omitempty"`
+	HomomorphicHash *grpc.Checksum `protobuf:"bytes,8,opt,name=homomorphic_hash,json=homomorphicHash,proto3" json:"homomorphic_hash,omitempty"`
 	// Session token, if it was used during Object creation.
 	// Need it to verify integrity and authenticity out of Request scope.
-	SessionToken *grpc.SessionToken `protobuf:"bytes,9,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
+	SessionToken *grpc1.SessionToken `protobuf:"bytes,9,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
 	// User-defined object attributes
 	Attributes []*Header_Attribute `protobuf:"bytes,10,rep,name=attributes,proto3" json:"attributes,omitempty"`
 	// Position of the object in the split hierarchy.
@@ -242,14 +242,14 @@ func (m *Header) GetVersion() *grpc.Version {
 	return nil
 }
 
-func (m *Header) GetContainerId() *grpc1.ContainerID {
+func (m *Header) GetContainerId() *grpc.ContainerID {
 	if m != nil {
 		return m.ContainerId
 	}
 	return nil
 }
 
-func (m *Header) GetOwnerId() *grpc1.OwnerID {
+func (m *Header) GetOwnerId() *grpc.OwnerID {
 	if m != nil {
 		return m.OwnerId
 	}
@@ -270,7 +270,7 @@ func (m *Header) GetPayloadLength() uint64 {
 	return 0
 }
 
-func (m *Header) GetPayloadHash() []byte {
+func (m *Header) GetPayloadHash() *grpc.Checksum {
 	if m != nil {
 		return m.PayloadHash
 	}
@@ -284,14 +284,14 @@ func (m *Header) GetObjectType() ObjectType {
 	return ObjectType_REGULAR
 }
 
-func (m *Header) GetHomomorphicHash() []byte {
+func (m *Header) GetHomomorphicHash() *grpc.Checksum {
 	if m != nil {
 		return m.HomomorphicHash
 	}
 	return nil
 }
 
-func (m *Header) GetSessionToken() *grpc.SessionToken {
+func (m *Header) GetSessionToken() *grpc1.SessionToken {
 	if m != nil {
 		return m.SessionToken
 	}
@@ -375,18 +375,18 @@ type Header_Split struct {
 	// Identifier of the origin object.
 	// Parent and children objects must be within the same container.
 	// Parent object_id is known only to the minor child.
-	Parent *grpc1.ObjectID `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
+	Parent *grpc.ObjectID `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
 	// Previous carries identifier of the left split neighbor.
-	Previous *grpc1.ObjectID `protobuf:"bytes,2,opt,name=previous,proto3" json:"previous,omitempty"`
+	Previous *grpc.ObjectID `protobuf:"bytes,2,opt,name=previous,proto3" json:"previous,omitempty"`
 	// `signature` field of the parent object. Used to reconstruct parent.
 	ParentSignature *grpc.Signature `protobuf:"bytes,3,opt,name=parent_signature,json=parentSignature,proto3" json:"parent_signature,omitempty"`
 	// `header` field of the parent object. Used to reconstruct parent.
 	ParentHeader *Header `protobuf:"bytes,4,opt,name=parent_header,json=parentHeader,proto3" json:"parent_header,omitempty"`
 	// Children carries list of identifiers of the objects generated by splitting the current.
-	Children             []*grpc1.ObjectID `protobuf:"bytes,5,rep,name=children,proto3" json:"children,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	Children             []*grpc.ObjectID `protobuf:"bytes,5,rep,name=children,proto3" json:"children,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *Header_Split) Reset()         { *m = Header_Split{} }
@@ -422,14 +422,14 @@ func (m *Header_Split) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Header_Split proto.InternalMessageInfo
 
-func (m *Header_Split) GetParent() *grpc1.ObjectID {
+func (m *Header_Split) GetParent() *grpc.ObjectID {
 	if m != nil {
 		return m.Parent
 	}
 	return nil
 }
 
-func (m *Header_Split) GetPrevious() *grpc1.ObjectID {
+func (m *Header_Split) GetPrevious() *grpc.ObjectID {
 	if m != nil {
 		return m.Previous
 	}
@@ -450,7 +450,7 @@ func (m *Header_Split) GetParentHeader() *Header {
 	return nil
 }
 
-func (m *Header_Split) GetChildren() []*grpc1.ObjectID {
+func (m *Header_Split) GetChildren() []*grpc.ObjectID {
 	if m != nil {
 		return m.Children
 	}
@@ -463,7 +463,7 @@ type Object struct {
 	// Object is content-addressed. It means id will change if header or payload
 	// changes. It's calculated as a hash of header field, which contains hash of
 	// object's payload
-	ObjectId *grpc1.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
+	ObjectId *grpc.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
 	// Signed object_id
 	Signature *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
 	// Object metadata headers
@@ -508,7 +508,7 @@ func (m *Object) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Object proto.InternalMessageInfo
 
-func (m *Object) GetObjectId() *grpc1.ObjectID {
+func (m *Object) GetObjectId() *grpc.ObjectID {
 	if m != nil {
 		return m.ObjectId
 	}
@@ -549,57 +549,57 @@ func init() {
 func init() { proto.RegisterFile("v2/object/grpc/types.proto", fileDescriptor_545319325da7b9b1) }
 
 var fileDescriptor_545319325da7b9b1 = []byte{
-	// 795 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xdd, 0x6e, 0xe3, 0x44,
-	0x14, 0xc7, 0xeb, 0xb4, 0xf9, 0x3a, 0x49, 0x76, 0xcd, 0x80, 0xc0, 0xca, 0xae, 0x42, 0xa8, 0x84,
-	0x14, 0x56, 0xaa, 0x8d, 0xbc, 0x45, 0x08, 0x56, 0x8b, 0x94, 0x36, 0xde, 0xd4, 0x52, 0xdb, 0x94,
-	0xb1, 0x8b, 0x04, 0x37, 0x96, 0x6b, 0x4f, 0x63, 0xb3, 0xa9, 0xc7, 0xf2, 0x4c, 0x8c, 0x7a, 0xcf,
-	0x43, 0xf0, 0x0c, 0x48, 0xdc, 0xf0, 0x12, 0x70, 0xc9, 0x23, 0xa0, 0xf2, 0x22, 0xc8, 0x33, 0x76,
-	0xfa, 0x91, 0x2e, 0x5b, 0xe0, 0x2a, 0x33, 0x27, 0xbf, 0xf3, 0xf5, 0x3f, 0x67, 0x64, 0xe8, 0xe7,
-	0xa6, 0x41, 0xcf, 0xbe, 0x27, 0x01, 0x37, 0xe6, 0x59, 0x1a, 0x18, 0xfc, 0x32, 0x25, 0x4c, 0x4f,
-	0x33, 0xca, 0x29, 0x52, 0x13, 0x42, 0xf5, 0x73, 0xa6, 0xe7, 0xa6, 0x2e, 0x91, 0xbe, 0x96, 0x9b,
-	0x46, 0x46, 0xce, 0xd9, 0x1a, 0xdb, 0x7f, 0x92, 0x9b, 0x06, 0x23, 0x59, 0x1e, 0x07, 0x64, 0xed,
-	0xcf, 0xed, 0x1f, 0x6b, 0xd0, 0x71, 0x22, 0x9a, 0xf1, 0x03, 0xe2, 0x87, 0x24, 0x43, 0xbb, 0xd0,
-	0xcc, 0x49, 0xc6, 0x62, 0x9a, 0x68, 0xca, 0x50, 0x19, 0x75, 0xcc, 0xbe, 0x7e, 0x9d, 0xaa, 0x8c,
-	0xa2, 0x7f, 0x23, 0x09, 0x5c, 0xa1, 0xe8, 0x63, 0x78, 0x14, 0x64, 0xc4, 0xe7, 0x31, 0x4d, 0x3c,
-	0x92, 0xd2, 0x20, 0xd2, 0x6a, 0x43, 0x65, 0xb4, 0x85, 0x7b, 0x95, 0xd5, 0x2a, 0x8c, 0xc8, 0x84,
-	0x16, 0xfd, 0x21, 0x21, 0x99, 0x17, 0x87, 0xda, 0xa6, 0x88, 0xfe, 0xc1, 0x8d, 0xe8, 0x45, 0xf5,
-	0xfa, 0xac, 0xf8, 0xdf, 0x9e, 0xe0, 0xa6, 0x00, 0xed, 0x10, 0xbd, 0x84, 0x8e, 0xec, 0xd0, 0x2b,
-	0xca, 0xd6, 0xb6, 0x86, 0xca, 0xe8, 0x91, 0xf9, 0x54, 0xbf, 0xdb, 0xbf, 0x3e, 0x13, 0x3f, 0xee,
-	0x65, 0x4a, 0x30, 0xd0, 0xd5, 0xb9, 0xa8, 0x2c, 0xf5, 0x2f, 0x17, 0xd4, 0x0f, 0xbd, 0x05, 0x49,
-	0xe6, 0x3c, 0xd2, 0xea, 0xb2, 0xb2, 0xd2, 0x7a, 0x28, 0x8c, 0xdb, 0xbf, 0x36, 0xa1, 0xf1, 0xbf,
-	0x14, 0xf8, 0x0a, 0xba, 0x01, 0x4d, 0xb8, 0x1f, 0x97, 0xed, 0xd5, 0x84, 0xeb, 0x93, 0xbb, 0xed,
-	0xed, 0x57, 0x8c, 0x3d, 0xc1, 0x9d, 0x95, 0x83, 0x1d, 0xfe, 0x27, 0x69, 0xd6, 0x55, 0xdf, 0xba,
-	0x4f, 0xf5, 0x87, 0x49, 0x80, 0x3e, 0x82, 0x6e, 0x85, 0x45, 0x3e, 0x8b, 0xb4, 0xc6, 0x50, 0x19,
-	0x75, 0x71, 0xa7, 0xb4, 0x1d, 0xf8, 0x2c, 0xba, 0x3b, 0x8b, 0xe6, 0xbf, 0x9c, 0xc5, 0x27, 0xa0,
-	0x46, 0xf4, 0x82, 0x5e, 0xd0, 0x2c, 0x8d, 0xe2, 0x40, 0x66, 0x69, 0x89, 0x2c, 0x8f, 0x6f, 0xd8,
-	0x45, 0xa6, 0x09, 0xf4, 0x18, 0x61, 0x85, 0xb2, 0x1e, 0xa7, 0xaf, 0x49, 0xa2, 0xb5, 0x85, 0x26,
-	0x1f, 0xde, 0x33, 0x0a, 0x47, 0x72, 0x6e, 0x81, 0xe1, 0x2e, 0xbb, 0x71, 0x43, 0x7b, 0x00, 0x3e,
-	0xe7, 0x59, 0x7c, 0xb6, 0xe4, 0x84, 0x69, 0x30, 0xdc, 0x1c, 0x75, 0xcc, 0xed, 0xf5, 0x72, 0xe5,
-	0xe0, 0xf5, 0x71, 0x85, 0xe2, 0x1b, 0x5e, 0x68, 0x17, 0xea, 0x2c, 0x5d, 0xc4, 0x5c, 0xeb, 0x88,
-	0x0a, 0x06, 0x6f, 0x74, 0x77, 0x0a, 0x0a, 0x4b, 0xb8, 0xff, 0x1c, 0xda, 0xab, 0x70, 0x48, 0x85,
-	0xcd, 0xd7, 0xe4, 0x52, 0x6c, 0x53, 0x1b, 0x17, 0x47, 0xf4, 0x1e, 0xd4, 0x73, 0x7f, 0xb1, 0x24,
-	0x62, 0x4d, 0xda, 0x58, 0x5e, 0xfa, 0xbf, 0xd4, 0xa0, 0x2e, 0xa2, 0xa0, 0x4f, 0xa1, 0x91, 0xfa,
-	0x19, 0x49, 0x78, 0xb9, 0x82, 0xda, 0xda, 0x2e, 0x88, 0xd4, 0xf6, 0x04, 0x97, 0x1c, 0xda, 0x85,
-	0x56, 0x9a, 0x91, 0x3c, 0xa6, 0x4b, 0x56, 0xee, 0xde, 0x9b, 0x7d, 0x56, 0x24, 0x9a, 0x82, 0x2a,
-	0xfd, 0x3d, 0x16, 0xcf, 0x13, 0x9f, 0x2f, 0x33, 0x52, 0x6e, 0xdf, 0xd3, 0xfb, 0x94, 0xae, 0x18,
-	0xfc, 0x58, 0x7a, 0xad, 0x0c, 0xe8, 0x25, 0xf4, 0xca, 0x40, 0x91, 0x50, 0x43, 0x6c, 0xe2, 0xed,
-	0x1a, 0x6e, 0xa9, 0x85, 0xbb, 0x12, 0x5f, 0xbd, 0xb9, 0x56, 0x10, 0xc5, 0x8b, 0x30, 0x23, 0x89,
-	0x56, 0x17, 0x63, 0xfa, 0x87, 0xea, 0x2b, 0x72, 0xfb, 0x37, 0x05, 0x1a, 0xd2, 0x8c, 0x3e, 0x83,
-	0x76, 0xb9, 0x99, 0x71, 0xf8, 0x56, 0xcd, 0x5a, 0x12, 0xb5, 0x43, 0xf4, 0x25, 0xb4, 0xaf, 0x1b,
-	0xaf, 0x3d, 0xa0, 0xf1, 0x6b, 0xbc, 0x98, 0x51, 0xd9, 0xeb, 0xe6, 0x5b, 0x7a, 0x2d, 0x39, 0xa4,
-	0x41, 0xb3, 0x7c, 0x4d, 0x42, 0x9e, 0x2e, 0xae, 0xae, 0xcf, 0x5e, 0x00, 0x5c, 0xbf, 0x19, 0xd4,
-	0x81, 0x26, 0xb6, 0xa6, 0xa7, 0x87, 0x63, 0xac, 0x6e, 0xa0, 0x1e, 0xb4, 0xdd, 0xd9, 0xd1, 0x9e,
-	0xe3, 0xce, 0x8e, 0x2d, 0x55, 0x41, 0xef, 0x40, 0xcf, 0x71, 0x67, 0x78, 0x3c, 0xb5, 0xbc, 0x29,
-	0x9e, 0x9d, 0x9e, 0xa8, 0xb5, 0x67, 0x5f, 0x40, 0xfb, 0xc8, 0xe7, 0x41, 0x24, 0x7c, 0xfb, 0xf0,
-	0xfe, 0xd1, 0xd8, 0xdd, 0x3f, 0xf0, 0xdc, 0x6f, 0x4f, 0x2c, 0xef, 0xf4, 0xd8, 0x39, 0xb1, 0xf6,
-	0xed, 0x57, 0xb6, 0x35, 0x51, 0x37, 0x90, 0x0a, 0x5d, 0xc7, 0xc5, 0xf6, 0xf1, 0xd4, 0xb3, 0xbe,
-	0x3e, 0x1d, 0x1f, 0xaa, 0xca, 0x9e, 0xf7, 0xfb, 0xd5, 0x40, 0xf9, 0xe3, 0x6a, 0xa0, 0xfc, 0x79,
-	0x35, 0x50, 0x7e, 0xfa, 0x6b, 0xb0, 0xf1, 0xdd, 0xe7, 0xf3, 0x98, 0x47, 0xcb, 0x33, 0x3d, 0xa0,
-	0x17, 0x46, 0xc2, 0xd2, 0x20, 0xd8, 0x09, 0x49, 0x6e, 0x24, 0x84, 0x9e, 0xb3, 0x1d, 0x3f, 0x8d,
-	0x77, 0xe6, 0xd4, 0xb8, 0xfd, 0x59, 0x7a, 0x21, 0xcf, 0x3f, 0xd7, 0xde, 0x3d, 0x26, 0xf4, 0x95,
-	0xa3, 0x8f, 0x4f, 0xec, 0x42, 0x01, 0xd9, 0xce, 0x59, 0x43, 0x7c, 0x65, 0x9e, 0xff, 0x1d, 0x00,
-	0x00, 0xff, 0xff, 0x30, 0x4b, 0x22, 0xa9, 0xcc, 0x06, 0x00, 0x00,
+	// 796 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x95, 0xdd, 0x6e, 0xe3, 0x44,
+	0x14, 0xc7, 0xeb, 0xb4, 0xf9, 0x3a, 0x4e, 0x76, 0xcd, 0x80, 0xc0, 0x64, 0x51, 0xa8, 0x2a, 0x21,
+	0x55, 0x2b, 0xd5, 0x06, 0x6f, 0xd1, 0x0a, 0x55, 0x8b, 0x94, 0x36, 0xde, 0xd6, 0x52, 0xdb, 0x94,
+	0xb1, 0x8b, 0x04, 0x37, 0x96, 0x6b, 0x4f, 0x63, 0xd3, 0xd4, 0x63, 0x79, 0x26, 0x46, 0xbd, 0xe4,
+	0x2d, 0x78, 0x86, 0x7d, 0x0e, 0x2e, 0xb8, 0xe4, 0x11, 0x56, 0xe5, 0x45, 0x90, 0x67, 0xec, 0xf4,
+	0x23, 0xbb, 0x04, 0xf6, 0xca, 0xf6, 0x99, 0xdf, 0xff, 0xcc, 0xf9, 0x9f, 0x39, 0x23, 0xc3, 0xa0,
+	0xb0, 0x4c, 0x7a, 0xf1, 0x0b, 0x09, 0xb9, 0x39, 0xcd, 0xb3, 0xd0, 0xe4, 0x37, 0x19, 0x61, 0x46,
+	0x96, 0x53, 0x4e, 0x91, 0x96, 0x12, 0x6a, 0x5c, 0x32, 0xa3, 0xb0, 0x0c, 0x89, 0x0c, 0xf4, 0xc2,
+	0x32, 0x73, 0x72, 0xc9, 0x96, 0xd8, 0xc1, 0xb3, 0xc2, 0x32, 0x19, 0x61, 0x2c, 0xa1, 0xe9, 0xd2,
+	0xe2, 0xd6, 0x6f, 0x0d, 0x50, 0xdd, 0x98, 0xe6, 0xfc, 0x88, 0x04, 0x11, 0xc9, 0xd1, 0x37, 0xd0,
+	0x2e, 0x48, 0x5e, 0xb2, 0xba, 0xb2, 0xa9, 0x6c, 0xab, 0xd6, 0x67, 0xc6, 0xdd, 0x56, 0x65, 0x7e,
+	0xe3, 0x47, 0xb9, 0x8c, 0x6b, 0x0e, 0x7d, 0x05, 0x4f, 0xc2, 0x9c, 0x04, 0x3c, 0xa1, 0xa9, 0x4f,
+	0x32, 0x1a, 0xc6, 0x7a, 0x63, 0x53, 0xd9, 0xde, 0xc0, 0xfd, 0x3a, 0x6a, 0x97, 0x41, 0x64, 0x41,
+	0x87, 0xfe, 0x9a, 0x92, 0xdc, 0x4f, 0x22, 0x7d, 0xfd, 0xdd, 0xa9, 0x27, 0xe5, 0xba, 0x33, 0xc6,
+	0x6d, 0x01, 0x3a, 0x11, 0x7a, 0x05, 0xaa, 0xb4, 0xe7, 0x97, 0x35, 0xeb, 0x1b, 0x9b, 0xca, 0xf6,
+	0x13, 0xeb, 0x0b, 0xe3, 0xb1, 0x79, 0x63, 0x22, 0x1e, 0xde, 0x4d, 0x46, 0x30, 0xd0, 0xc5, 0x7b,
+	0x59, 0x59, 0x16, 0xdc, 0xcc, 0x68, 0x10, 0xf9, 0x33, 0x92, 0x4e, 0x79, 0xac, 0x37, 0x65, 0x65,
+	0x55, 0xf4, 0x58, 0x04, 0xb7, 0xde, 0xb6, 0xa1, 0xf5, 0xe1, 0xf6, 0xbf, 0x87, 0x5e, 0x48, 0x53,
+	0x1e, 0x24, 0x95, 0xb7, 0x86, 0xd0, 0x3d, 0x7b, 0xac, 0x3b, 0xa8, 0x19, 0x67, 0x8c, 0xd5, 0x85,
+	0xc0, 0x89, 0x3e, 0xa8, 0x2f, 0xcb, 0x2d, 0xdf, 0x78, 0x57, 0xcb, 0xff, 0x9b, 0x7f, 0xb4, 0x07,
+	0xbd, 0x1a, 0x8b, 0x03, 0x16, 0xeb, 0x2d, 0x51, 0x85, 0xbe, 0xe4, 0x20, 0x26, 0xe1, 0x15, 0x9b,
+	0x5f, 0x63, 0xb5, 0xa2, 0x8f, 0x02, 0x16, 0x3f, 0x3e, 0xa2, 0xf6, 0xff, 0x3c, 0xa2, 0x03, 0xd0,
+	0x62, 0x7a, 0x4d, 0xaf, 0x69, 0x9e, 0xc5, 0x49, 0x28, 0xf7, 0xef, 0xac, 0xd8, 0xff, 0xe9, 0x3d,
+	0x85, 0xa8, 0x61, 0x0c, 0xfd, 0x6a, 0xc0, 0x7d, 0x4e, 0xaf, 0x48, 0xaa, 0x77, 0x45, 0x86, 0x2f,
+	0xef, 0x65, 0xa8, 0xd6, 0x0d, 0x57, 0x3e, 0xbd, 0x12, 0xc3, 0x3d, 0x76, 0xef, 0x0b, 0xed, 0x03,
+	0x04, 0x9c, 0xe7, 0xc9, 0xc5, 0x9c, 0x13, 0xa6, 0xc3, 0xe6, 0xfa, 0xb6, 0x6a, 0x6d, 0x2d, 0x1b,
+	0x91, 0x93, 0x62, 0x8c, 0x6a, 0x14, 0xdf, 0x53, 0xa1, 0x5d, 0x68, 0xb2, 0x6c, 0x96, 0x70, 0x5d,
+	0x15, 0x15, 0x0c, 0xdf, 0x2b, 0x77, 0x4b, 0x0a, 0x4b, 0x78, 0xf0, 0x02, 0xba, 0x8b, 0x74, 0x48,
+	0x83, 0xf5, 0x2b, 0x72, 0x23, 0xc6, 0xaf, 0x8b, 0xcb, 0x57, 0xf4, 0x09, 0x34, 0x8b, 0x60, 0x36,
+	0x27, 0x62, 0xb4, 0xba, 0x58, 0x7e, 0x0c, 0xde, 0x34, 0xa0, 0x29, 0xb2, 0xa0, 0xaf, 0xa1, 0x95,
+	0x05, 0x39, 0x49, 0x79, 0x35, 0xb3, 0x4b, 0x9d, 0x93, 0xbd, 0x77, 0xc6, 0xb8, 0xe2, 0xd0, 0x2e,
+	0x74, 0xb2, 0x9c, 0x14, 0x09, 0x9d, 0xb3, 0x6a, 0x5e, 0xdf, 0xaf, 0x59, 0x90, 0x68, 0x0c, 0x9a,
+	0xd4, 0xfb, 0x2c, 0x99, 0xa6, 0x01, 0x9f, 0xe7, 0xa4, 0x9a, 0xd8, 0xcf, 0x1f, 0xab, 0xdd, 0x1a,
+	0xc0, 0x4f, 0xa5, 0x64, 0x11, 0x40, 0xaf, 0xa0, 0x5f, 0x65, 0x89, 0x45, 0x2b, 0xc4, 0xe8, 0x3e,
+	0x2c, 0xe0, 0x41, 0xab, 0x70, 0x4f, 0xe2, 0xd5, 0x0d, 0xdd, 0x85, 0x4e, 0x18, 0x27, 0xb3, 0x28,
+	0x27, 0xa9, 0xde, 0x14, 0x67, 0xf4, 0x2f, 0xa5, 0xd7, 0xe4, 0xd6, 0x1f, 0x0a, 0xb4, 0x64, 0x18,
+	0x7d, 0x0b, 0xdd, 0x6a, 0x60, 0x93, 0x68, 0x65, 0xc3, 0x3a, 0x12, 0x75, 0x22, 0xf4, 0x12, 0xba,
+	0x77, 0xae, 0x1b, 0xab, 0x5c, 0xdf, 0xb1, 0xe5, 0xe9, 0x54, 0x46, 0xd7, 0x57, 0x18, 0xad, 0x38,
+	0xa4, 0x43, 0xbb, 0xba, 0x61, 0xa2, 0x37, 0x3d, 0x5c, 0x7f, 0x3e, 0xdf, 0x03, 0xb8, 0xbb, 0x47,
+	0x48, 0x85, 0x36, 0xb6, 0x0f, 0xcf, 0x8f, 0x47, 0x58, 0x5b, 0x43, 0x7d, 0xe8, 0x7a, 0x93, 0x93,
+	0x7d, 0xd7, 0x9b, 0x9c, 0xda, 0x9a, 0x82, 0x3e, 0x82, 0xbe, 0xeb, 0x4d, 0xf0, 0xe8, 0xd0, 0xf6,
+	0x0f, 0xf1, 0xe4, 0xfc, 0x4c, 0x6b, 0x3c, 0xff, 0x0e, 0xba, 0x27, 0x01, 0x0f, 0x63, 0xa1, 0x1d,
+	0xc0, 0xa7, 0x27, 0x23, 0xef, 0xe0, 0xc8, 0xf7, 0x7e, 0x3a, 0xb3, 0xfd, 0xf3, 0x53, 0xf7, 0xcc,
+	0x3e, 0x70, 0x5e, 0x3b, 0xf6, 0x58, 0x5b, 0x43, 0x1a, 0xf4, 0x5c, 0x0f, 0x3b, 0xa7, 0x87, 0xbe,
+	0xfd, 0xc3, 0xf9, 0xe8, 0x58, 0x53, 0xf6, 0xfd, 0x3f, 0x6f, 0x87, 0xca, 0x5f, 0xb7, 0x43, 0xe5,
+	0xed, 0xed, 0x50, 0xf9, 0xfd, 0xef, 0xe1, 0xda, 0xcf, 0x2f, 0xa7, 0x09, 0x8f, 0xe7, 0x17, 0x46,
+	0x48, 0xaf, 0xcd, 0x94, 0x65, 0x61, 0xb8, 0x13, 0x91, 0xc2, 0x4c, 0x09, 0xbd, 0x64, 0x3b, 0x41,
+	0x96, 0xec, 0x4c, 0xa9, 0xf9, 0xf0, 0xf7, 0xb5, 0x27, 0xdf, 0xdf, 0x34, 0x3e, 0x3e, 0x25, 0xf4,
+	0xb5, 0x6b, 0x8c, 0xce, 0x9c, 0xb2, 0x03, 0xd2, 0xce, 0x45, 0x4b, 0xfc, 0x8d, 0x5e, 0xfc, 0x13,
+	0x00, 0x00, 0xff, 0xff, 0x2c, 0x8c, 0x1d, 0x72, 0xf4, 0x06, 0x00, 0x00,
 }
 
 func (m *ShortHeader) Marshal() (dAtA []byte, err error) {
@@ -730,10 +730,15 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x4a
 	}
-	if len(m.HomomorphicHash) > 0 {
-		i -= len(m.HomomorphicHash)
-		copy(dAtA[i:], m.HomomorphicHash)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.HomomorphicHash)))
+	if m.HomomorphicHash != nil {
+		{
+			size, err := m.HomomorphicHash.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
 		i--
 		dAtA[i] = 0x42
 	}
@@ -742,10 +747,15 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x38
 	}
-	if len(m.PayloadHash) > 0 {
-		i -= len(m.PayloadHash)
-		copy(dAtA[i:], m.PayloadHash)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.PayloadHash)))
+	if m.PayloadHash != nil {
+		{
+			size, err := m.PayloadHash.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
 		i--
 		dAtA[i] = 0x32
 	}
@@ -1062,15 +1072,15 @@ func (m *Header) Size() (n int) {
 	if m.PayloadLength != 0 {
 		n += 1 + sovTypes(uint64(m.PayloadLength))
 	}
-	l = len(m.PayloadHash)
-	if l > 0 {
+	if m.PayloadHash != nil {
+		l = m.PayloadHash.Size()
 		n += 1 + l + sovTypes(uint64(l))
 	}
 	if m.ObjectType != 0 {
 		n += 1 + sovTypes(uint64(m.ObjectType))
 	}
-	l = len(m.HomomorphicHash)
-	if l > 0 {
+	if m.HomomorphicHash != nil {
+		l = m.HomomorphicHash.Size()
 		n += 1 + l + sovTypes(uint64(l))
 	}
 	if m.SessionToken != nil {
@@ -1295,7 +1305,7 @@ func (m *ShortHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.OwnerId == nil {
-				m.OwnerId = &grpc1.OwnerID{}
+				m.OwnerId = &grpc.OwnerID{}
 			}
 			if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -1459,7 +1469,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.ContainerId == nil {
-				m.ContainerId = &grpc1.ContainerID{}
+				m.ContainerId = &grpc.ContainerID{}
 			}
 			if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -1495,7 +1505,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.OwnerId == nil {
-				m.OwnerId = &grpc1.OwnerID{}
+				m.OwnerId = &grpc.OwnerID{}
 			}
 			if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -1543,7 +1553,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field PayloadHash", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -1553,24 +1563,26 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthTypes
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PayloadHash = append(m.PayloadHash[:0], dAtA[iNdEx:postIndex]...)
 			if m.PayloadHash == nil {
-				m.PayloadHash = []byte{}
+				m.PayloadHash = &grpc.Checksum{}
+			}
+			if err := m.PayloadHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 7:
@@ -1596,7 +1608,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field HomomorphicHash", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -1606,24 +1618,26 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthTypes
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.HomomorphicHash = append(m.HomomorphicHash[:0], dAtA[iNdEx:postIndex]...)
 			if m.HomomorphicHash == nil {
-				m.HomomorphicHash = []byte{}
+				m.HomomorphicHash = &grpc.Checksum{}
+			}
+			if err := m.HomomorphicHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 9:
@@ -1656,7 +1670,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.SessionToken == nil {
-				m.SessionToken = &grpc.SessionToken{}
+				m.SessionToken = &grpc1.SessionToken{}
 			}
 			if err := m.SessionToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -1934,7 +1948,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Parent == nil {
-				m.Parent = &grpc1.ObjectID{}
+				m.Parent = &grpc.ObjectID{}
 			}
 			if err := m.Parent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -1970,7 +1984,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Previous == nil {
-				m.Previous = &grpc1.ObjectID{}
+				m.Previous = &grpc.ObjectID{}
 			}
 			if err := m.Previous.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -2077,7 +2091,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Children = append(m.Children, &grpc1.ObjectID{})
+			m.Children = append(m.Children, &grpc.ObjectID{})
 			if err := m.Children[len(m.Children)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2166,7 +2180,7 @@ func (m *Object) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.ObjectId == nil {
-				m.ObjectId = &grpc1.ObjectID{}
+				m.ObjectId = &grpc.ObjectID{}
 			}
 			if err := m.ObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
diff --git a/v2/refs/grpc/types.pb.go b/v2/refs/grpc/types.pb.go
index 7634600..91878d0 100644
--- a/v2/refs/grpc/types.pb.go
+++ b/v2/refs/grpc/types.pb.go
@@ -22,6 +22,38 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
+// Checksum algorithm type
+type ChecksumType int32
+
+const (
+	// Unknown. Not used
+	ChecksumType_CHECKSUM_TYPE_UNSPECIFIED ChecksumType = 0
+	// Tillich-Zemor homomorphic hash funciton
+	ChecksumType_TZ ChecksumType = 1
+	// SHA-256
+	ChecksumType_SHA256 ChecksumType = 2
+)
+
+var ChecksumType_name = map[int32]string{
+	0: "CHECKSUM_TYPE_UNSPECIFIED",
+	1: "TZ",
+	2: "SHA256",
+}
+
+var ChecksumType_value = map[string]int32{
+	"CHECKSUM_TYPE_UNSPECIFIED": 0,
+	"TZ":                        1,
+	"SHA256":                    2,
+}
+
+func (x ChecksumType) String() string {
+	return proto.EnumName(ChecksumType_name, int32(x))
+}
+
+func (ChecksumType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_08f084e5f91ec87c, []int{0}
+}
+
 // Address of object (container id + object id)
 type Address struct {
 	// container_id carries container identifier.
@@ -227,34 +259,222 @@ func (m *OwnerID) GetValue() []byte {
 	return nil
 }
 
+// Represents API version used by node.
+type Version struct {
+	// Major API version.
+	Major uint32 `protobuf:"varint,1,opt,name=major,proto3" json:"major,omitempty"`
+	// Minor API version.
+	Minor                uint32   `protobuf:"varint,2,opt,name=minor,proto3" json:"minor,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Version) Reset()         { *m = Version{} }
+func (m *Version) String() string { return proto.CompactTextString(m) }
+func (*Version) ProtoMessage()    {}
+func (*Version) Descriptor() ([]byte, []int) {
+	return fileDescriptor_08f084e5f91ec87c, []int{4}
+}
+func (m *Version) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Version.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Version) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Version.Merge(m, src)
+}
+func (m *Version) XXX_Size() int {
+	return m.Size()
+}
+func (m *Version) XXX_DiscardUnknown() {
+	xxx_messageInfo_Version.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Version proto.InternalMessageInfo
+
+func (m *Version) GetMajor() uint32 {
+	if m != nil {
+		return m.Major
+	}
+	return 0
+}
+
+func (m *Version) GetMinor() uint32 {
+	if m != nil {
+		return m.Minor
+	}
+	return 0
+}
+
+// Signature of something in NeoFS
+type Signature struct {
+	// Public key used for signing.
+	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// Signature
+	Sign                 []byte   `protobuf:"bytes,2,opt,name=sign,proto3" json:"sign,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Signature) Reset()         { *m = Signature{} }
+func (m *Signature) String() string { return proto.CompactTextString(m) }
+func (*Signature) ProtoMessage()    {}
+func (*Signature) Descriptor() ([]byte, []int) {
+	return fileDescriptor_08f084e5f91ec87c, []int{5}
+}
+func (m *Signature) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Signature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Signature.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Signature) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Signature.Merge(m, src)
+}
+func (m *Signature) XXX_Size() int {
+	return m.Size()
+}
+func (m *Signature) XXX_DiscardUnknown() {
+	xxx_messageInfo_Signature.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Signature proto.InternalMessageInfo
+
+func (m *Signature) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *Signature) GetSign() []byte {
+	if m != nil {
+		return m.Sign
+	}
+	return nil
+}
+
+// Checksum message
+type Checksum struct {
+	// Checksum algorithm type
+	Type ChecksumType `protobuf:"varint,1,opt,name=type,proto3,enum=neo.fs.v2.refs.ChecksumType" json:"type,omitempty"`
+	// Checksum itself
+	Sum                  []byte   `protobuf:"bytes,2,opt,name=sum,proto3" json:"sum,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Checksum) Reset()         { *m = Checksum{} }
+func (m *Checksum) String() string { return proto.CompactTextString(m) }
+func (*Checksum) ProtoMessage()    {}
+func (*Checksum) Descriptor() ([]byte, []int) {
+	return fileDescriptor_08f084e5f91ec87c, []int{6}
+}
+func (m *Checksum) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Checksum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Checksum.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Checksum) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Checksum.Merge(m, src)
+}
+func (m *Checksum) XXX_Size() int {
+	return m.Size()
+}
+func (m *Checksum) XXX_DiscardUnknown() {
+	xxx_messageInfo_Checksum.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Checksum proto.InternalMessageInfo
+
+func (m *Checksum) GetType() ChecksumType {
+	if m != nil {
+		return m.Type
+	}
+	return ChecksumType_CHECKSUM_TYPE_UNSPECIFIED
+}
+
+func (m *Checksum) GetSum() []byte {
+	if m != nil {
+		return m.Sum
+	}
+	return nil
+}
+
 func init() {
+	proto.RegisterEnum("neo.fs.v2.refs.ChecksumType", ChecksumType_name, ChecksumType_value)
 	proto.RegisterType((*Address)(nil), "neo.fs.v2.refs.Address")
 	proto.RegisterType((*ObjectID)(nil), "neo.fs.v2.refs.ObjectID")
 	proto.RegisterType((*ContainerID)(nil), "neo.fs.v2.refs.ContainerID")
 	proto.RegisterType((*OwnerID)(nil), "neo.fs.v2.refs.OwnerID")
+	proto.RegisterType((*Version)(nil), "neo.fs.v2.refs.Version")
+	proto.RegisterType((*Signature)(nil), "neo.fs.v2.refs.Signature")
+	proto.RegisterType((*Checksum)(nil), "neo.fs.v2.refs.Checksum")
 }
 
 func init() { proto.RegisterFile("v2/refs/grpc/types.proto", fileDescriptor_08f084e5f91ec87c) }
 
 var fileDescriptor_08f084e5f91ec87c = []byte{
-	// 265 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x33, 0xd2, 0x2f,
-	0x4a, 0x4d, 0x2b, 0xd6, 0x4f, 0x2f, 0x2a, 0x48, 0xd6, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b,
-	0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xcb, 0x4b, 0xcd, 0xd7, 0x4b, 0x2b, 0xd6, 0x2b, 0x33, 0xd2,
-	0x03, 0x29, 0x50, 0x6a, 0x60, 0xe4, 0x62, 0x77, 0x4c, 0x49, 0x29, 0x4a, 0x2d, 0x2e, 0x16, 0xb2,
-	0xe3, 0xe2, 0x49, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x8a, 0xcf, 0x4c, 0x91, 0x60,
-	0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd6, 0x43, 0xd5, 0xa2, 0xe7, 0x0c, 0x53, 0xe3, 0xe9, 0x12,
-	0xc4, 0x0d, 0xd7, 0xe0, 0x99, 0x22, 0x64, 0xca, 0xc5, 0x99, 0x9f, 0x94, 0x95, 0x9a, 0x5c, 0x02,
-	0xd2, 0xcc, 0x04, 0xd6, 0x2c, 0x81, 0xae, 0xd9, 0x1f, 0xac, 0xc0, 0xd3, 0x25, 0x88, 0x03, 0xa2,
-	0xd4, 0x33, 0x45, 0x49, 0x81, 0x8b, 0x03, 0x26, 0x2a, 0x24, 0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53,
-	0x9a, 0x0a, 0xb6, 0x9b, 0x27, 0x08, 0xc2, 0x51, 0x52, 0xe6, 0xe2, 0x46, 0xb2, 0x14, 0x87, 0x22,
-	0x79, 0x2e, 0x76, 0xff, 0x72, 0x3c, 0x0a, 0x9c, 0x22, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48,
-	0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x19, 0x8f, 0xe5, 0x18, 0xa2, 0x8c, 0xd3, 0x33, 0x4b, 0x32,
-	0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xf3, 0x8a, 0x0b, 0x92, 0x93, 0x75, 0x53, 0x52, 0xcb,
-	0xf4, 0xf3, 0x52, 0xf3, 0xd3, 0x8a, 0x75, 0x13, 0x0b, 0x32, 0x75, 0xd3, 0xf3, 0xf5, 0x91, 0x03,
-	0xd2, 0x1a, 0xc4, 0x5a, 0xc5, 0x24, 0xe8, 0x97, 0x9a, 0xef, 0x16, 0xac, 0xe7, 0x18, 0xe0, 0x09,
-	0xf2, 0x55, 0x50, 0x6a, 0x5a, 0x71, 0x12, 0x1b, 0x38, 0x70, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff,
-	0xff, 0x64, 0x50, 0x7b, 0x92, 0x78, 0x01, 0x00, 0x00,
+	// 427 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xc1, 0x6e, 0xd3, 0x40,
+	0x10, 0x86, 0xeb, 0x50, 0x92, 0x74, 0x12, 0xaa, 0xb0, 0xe2, 0x10, 0x04, 0x84, 0xca, 0x5c, 0x10,
+	0x52, 0xd6, 0xe0, 0x2a, 0x5c, 0x90, 0x90, 0x82, 0x93, 0xaa, 0x16, 0x22, 0x8d, 0xec, 0x14, 0xa9,
+	0xbd, 0x44, 0x8e, 0x3d, 0x71, 0xb7, 0x25, 0xbb, 0xd6, 0xae, 0x6d, 0x94, 0x1b, 0x8f, 0xc1, 0x33,
+	0xf0, 0x24, 0x1c, 0x79, 0x04, 0x14, 0x5e, 0x04, 0xed, 0x26, 0x41, 0x01, 0x04, 0xb7, 0x7f, 0x46,
+	0xdf, 0xb7, 0x63, 0x8f, 0x06, 0xda, 0xa5, 0xeb, 0x48, 0x9c, 0x2b, 0x27, 0x95, 0x59, 0xec, 0xe4,
+	0xcb, 0x0c, 0x15, 0xcd, 0xa4, 0xc8, 0x05, 0x39, 0xe4, 0x28, 0xe8, 0x5c, 0xd1, 0xd2, 0xa5, 0x1a,
+	0xb0, 0x3f, 0x59, 0x50, 0xeb, 0x27, 0x89, 0x44, 0xa5, 0xc8, 0x6b, 0x68, 0xc6, 0x82, 0xe7, 0x11,
+	0xe3, 0x28, 0xa7, 0x2c, 0x69, 0x5b, 0x47, 0xd6, 0xd3, 0x86, 0xfb, 0x80, 0xfe, 0xae, 0x50, 0x6f,
+	0xcb, 0xf8, 0x83, 0xa0, 0xf1, 0x4b, 0xf0, 0x13, 0xd2, 0x83, 0x03, 0x31, 0xbb, 0xc6, 0x38, 0xd7,
+	0x72, 0xc5, 0xc8, 0xed, 0x3f, 0xe5, 0x33, 0x03, 0xf8, 0x83, 0xa0, 0xbe, 0x46, 0xfd, 0xc4, 0x3e,
+	0x82, 0xfa, 0xb6, 0x4b, 0xee, 0xc1, 0xed, 0x32, 0xfa, 0x50, 0xa0, 0x99, 0xdd, 0x0c, 0xd6, 0x85,
+	0xfd, 0x04, 0x1a, 0x3b, 0x43, 0xff, 0x01, 0x3d, 0x86, 0xda, 0xd9, 0xc7, 0xff, 0x01, 0x3d, 0xa8,
+	0xbd, 0x47, 0xa9, 0x98, 0xe0, 0x1a, 0x58, 0x44, 0xd7, 0x42, 0x1a, 0xe0, 0x4e, 0xb0, 0x2e, 0x4c,
+	0x97, 0x71, 0x21, 0xcd, 0xb7, 0xeb, 0xae, 0x2e, 0xec, 0x17, 0x70, 0x10, 0xb2, 0x94, 0x47, 0x79,
+	0x21, 0x91, 0xb4, 0xe0, 0xd6, 0x0d, 0x2e, 0x37, 0xef, 0xea, 0x48, 0x08, 0xec, 0x2b, 0x96, 0x72,
+	0xe3, 0x34, 0x03, 0x93, 0xed, 0x11, 0xd4, 0xbd, 0x2b, 0x8c, 0x6f, 0x54, 0xb1, 0x20, 0xcf, 0x61,
+	0x5f, 0xef, 0xdf, 0x28, 0x87, 0xee, 0xc3, 0xbf, 0x96, 0xb9, 0xe1, 0x26, 0xcb, 0x0c, 0x03, 0x43,
+	0xea, 0x19, 0xaa, 0x58, 0x6c, 0x1e, 0xd4, 0xf1, 0x59, 0x1f, 0x9a, 0xbb, 0x1c, 0x79, 0x04, 0xf7,
+	0xbd, 0xd3, 0xa1, 0xf7, 0x36, 0x3c, 0x7f, 0x37, 0x9d, 0x5c, 0x8c, 0x87, 0xd3, 0xf3, 0x51, 0x38,
+	0x1e, 0x7a, 0xfe, 0x89, 0x3f, 0x1c, 0xb4, 0xf6, 0x48, 0x15, 0x2a, 0x93, 0xcb, 0x96, 0x45, 0x00,
+	0xaa, 0xe1, 0x69, 0xdf, 0xed, 0xbd, 0x6c, 0x55, 0xde, 0x5c, 0x7c, 0x5d, 0x75, 0xac, 0x6f, 0xab,
+	0x8e, 0xf5, 0x7d, 0xd5, 0xb1, 0x3e, 0xff, 0xe8, 0xec, 0x5d, 0x1e, 0xa7, 0x2c, 0xbf, 0x2a, 0x66,
+	0x34, 0x16, 0x0b, 0x87, 0xab, 0x2c, 0x8e, 0xbb, 0x09, 0x96, 0x0e, 0x47, 0x31, 0x57, 0xdd, 0x28,
+	0x63, 0xdd, 0x54, 0x38, 0xbb, 0x57, 0xf4, 0x4a, 0xa7, 0x2f, 0x95, 0xbb, 0x23, 0x14, 0x27, 0x21,
+	0xed, 0x8f, 0x7d, 0xfd, 0x0b, 0x01, 0xce, 0xd5, 0xac, 0x6a, 0x2e, 0xeb, 0xf8, 0x67, 0x00, 0x00,
+	0x00, 0xff, 0xff, 0xbb, 0x23, 0xc5, 0xde, 0x75, 0x02, 0x00, 0x00,
 }
 
 func (m *Address) Marshal() (dAtA []byte, err error) {
@@ -410,6 +630,123 @@ func (m *OwnerID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *Version) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Version) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Version) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Minor != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Minor))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Major != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Major))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Signature) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Signature) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Signature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Sign) > 0 {
+		i -= len(m.Sign)
+		copy(dAtA[i:], m.Sign)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sign)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Key) > 0 {
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Checksum) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Checksum) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Checksum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Sum) > 0 {
+		i -= len(m.Sum)
+		copy(dAtA[i:], m.Sum)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sum)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Type != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTypes(v)
 	base := offset
@@ -489,6 +826,63 @@ func (m *OwnerID) Size() (n int) {
 	return n
 }
 
+func (m *Version) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Major != 0 {
+		n += 1 + sovTypes(uint64(m.Major))
+	}
+	if m.Minor != 0 {
+		n += 1 + sovTypes(uint64(m.Minor))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Signature) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.Sign)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Checksum) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Type != 0 {
+		n += 1 + sovTypes(uint64(m.Type))
+	}
+	l = len(m.Sum)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func sovTypes(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -885,6 +1279,327 @@ func (m *OwnerID) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *Version) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Version: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Major", wireType)
+			}
+			m.Major = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Major |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Minor", wireType)
+			}
+			m.Minor = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Minor |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Signature) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Signature: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Signature: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sign", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Sign = append(m.Sign[:0], dAtA[iNdEx:postIndex]...)
+			if m.Sign == nil {
+				m.Sign = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Checksum) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Checksum: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Checksum: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= ChecksumType(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Sum = append(m.Sum[:0], dAtA[iNdEx:postIndex]...)
+			if m.Sum == nil {
+				m.Sum = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTypes(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/v2/session/grpc/service.pb.go b/v2/session/grpc/service.pb.go
index da92abe..e96f4c8 100644
--- a/v2/session/grpc/service.pb.go
+++ b/v2/session/grpc/service.pb.go
@@ -7,9 +7,8 @@ import (
 	context "context"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
-	grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
-	grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
-	grpc2 "google.golang.org/grpc"
+	grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
+	grpc1 "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
 	io "io"
@@ -34,13 +33,13 @@ type CreateRequest struct {
 	Body *CreateRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
 	// Carries request meta information. Header data is used only to regulate message
 	// transport and does not affect request execution.
-	MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
+	MetaHeader *RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
 	// Carries request verification information. This header is used to authenticate
 	// the nodes of the message route and check the correctness of transmission.
-	VerifyHeader         *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
-	XXX_unrecognized     []byte                          `json:"-"`
-	XXX_sizecache        int32                           `json:"-"`
+	VerifyHeader         *RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
+	XXX_unrecognized     []byte                     `json:"-"`
+	XXX_sizecache        int32                      `json:"-"`
 }
 
 func (m *CreateRequest) Reset()         { *m = CreateRequest{} }
@@ -83,14 +82,14 @@ func (m *CreateRequest) GetBody() *CreateRequest_Body {
 	return nil
 }
 
-func (m *CreateRequest) GetMetaHeader() *grpc.RequestMetaHeader {
+func (m *CreateRequest) GetMetaHeader() *RequestMetaHeader {
 	if m != nil {
 		return m.MetaHeader
 	}
 	return nil
 }
 
-func (m *CreateRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
+func (m *CreateRequest) GetVerifyHeader() *RequestVerificationHeader {
 	if m != nil {
 		return m.VerifyHeader
 	}
@@ -100,12 +99,12 @@ func (m *CreateRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
 // Request body
 type CreateRequest_Body struct {
 	// Carries an identifier of a session initiator.
-	OwnerId *grpc1.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
-	// Carries a lifetime of the session.
-	Lifetime             *grpc.TokenLifetime `protobuf:"bytes,2,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
-	XXX_unrecognized     []byte              `json:"-"`
-	XXX_sizecache        int32               `json:"-"`
+	OwnerId *grpc.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
+	// Expiration Epoch
+	Expiration           uint64   `protobuf:"varint,2,opt,name=expiration,proto3" json:"expiration,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *CreateRequest_Body) Reset()         { *m = CreateRequest_Body{} }
@@ -141,18 +140,18 @@ func (m *CreateRequest_Body) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_CreateRequest_Body proto.InternalMessageInfo
 
-func (m *CreateRequest_Body) GetOwnerId() *grpc1.OwnerID {
+func (m *CreateRequest_Body) GetOwnerId() *grpc.OwnerID {
 	if m != nil {
 		return m.OwnerId
 	}
 	return nil
 }
 
-func (m *CreateRequest_Body) GetLifetime() *grpc.TokenLifetime {
+func (m *CreateRequest_Body) GetExpiration() uint64 {
 	if m != nil {
-		return m.Lifetime
+		return m.Expiration
 	}
-	return nil
+	return 0
 }
 
 // CreateResponse carries an information about the opened session.
@@ -161,14 +160,14 @@ type CreateResponse struct {
 	Body *CreateResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
 	// Carries response meta information. Header data is used only to regulate
 	// message transport and does not affect request execution.
-	MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
+	MetaHeader *ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
 	// Carries response verification information. This header is used to
 	// authenticate the nodes of the message route and check the correctness
 	// of transmission.
-	VerifyHeader         *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
-	XXX_unrecognized     []byte                           `json:"-"`
-	XXX_sizecache        int32                            `json:"-"`
+	VerifyHeader         *ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
+	XXX_unrecognized     []byte                      `json:"-"`
+	XXX_sizecache        int32                       `json:"-"`
 }
 
 func (m *CreateResponse) Reset()         { *m = CreateResponse{} }
@@ -211,14 +210,14 @@ func (m *CreateResponse) GetBody() *CreateResponse_Body {
 	return nil
 }
 
-func (m *CreateResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
+func (m *CreateResponse) GetMetaHeader() *ResponseMetaHeader {
 	if m != nil {
 		return m.MetaHeader
 	}
 	return nil
 }
 
-func (m *CreateResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
+func (m *CreateResponse) GetVerifyHeader() *ResponseVerificationHeader {
 	if m != nil {
 		return m.VerifyHeader
 	}
@@ -293,63 +292,62 @@ func init() {
 func init() { proto.RegisterFile("v2/session/grpc/service.proto", fileDescriptor_4ed1365cc8e16cd4) }
 
 var fileDescriptor_4ed1365cc8e16cd4 = []byte{
-	// 458 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0x4f, 0x6f, 0xd3, 0x30,
-	0x18, 0xc6, 0x49, 0x98, 0xc6, 0xe4, 0x76, 0x95, 0xb0, 0x90, 0xa8, 0x8a, 0x28, 0x65, 0x62, 0x88,
-	0x03, 0x75, 0xa4, 0x70, 0x40, 0x03, 0x2e, 0x0c, 0x98, 0xa8, 0x60, 0xfc, 0x71, 0x11, 0x07, 0x2e,
-	0x51, 0xfe, 0xbc, 0xe9, 0xac, 0x11, 0x3b, 0xd8, 0x5e, 0x20, 0xdf, 0x84, 0x2b, 0x57, 0x3e, 0x09,
-	0x47, 0x3e, 0x01, 0x42, 0xe5, 0x8b, 0xa0, 0xd8, 0xde, 0xb4, 0x6e, 0x59, 0x7b, 0xcb, 0x1b, 0x3f,
-	0xcf, 0xf3, 0xbe, 0xef, 0x4f, 0x36, 0xba, 0x59, 0x85, 0x81, 0x02, 0xa5, 0x98, 0xe0, 0xc1, 0x4c,
-	0x96, 0x69, 0xa0, 0x40, 0x56, 0x2c, 0x05, 0x52, 0x4a, 0xa1, 0x05, 0xbe, 0xca, 0x41, 0x90, 0x5c,
-	0x91, 0x2a, 0x24, 0x4e, 0x35, 0xe8, 0x57, 0x61, 0x20, 0x21, 0x57, 0x56, 0xae, 0xeb, 0x12, 0x94,
-	0x15, 0x0f, 0x6e, 0x98, 0x2c, 0x63, 0x3f, 0x77, 0xb8, 0xf5, 0xc7, 0x47, 0x9b, 0xcf, 0x24, 0xc4,
-	0x1a, 0x28, 0x7c, 0x39, 0x02, 0xa5, 0xf1, 0x0e, 0x5a, 0x4b, 0x44, 0x56, 0xf7, 0xbd, 0x91, 0x77,
-	0xaf, 0x13, 0x6e, 0x93, 0x73, 0xad, 0xc8, 0x82, 0x9e, 0xec, 0x8a, 0xac, 0xa6, 0xc6, 0x82, 0x5f,
-	0xa0, 0x4e, 0x01, 0x3a, 0x8e, 0x0e, 0x20, 0xce, 0x40, 0xf6, 0x7d, 0x93, 0x70, 0x67, 0x21, 0xc1,
-	0x6e, 0xe1, 0xbc, 0xfb, 0xa0, 0xe3, 0x97, 0x46, 0x4b, 0x51, 0x71, 0xf2, 0x8d, 0xdf, 0xa3, 0xcd,
-	0x0a, 0x24, 0xcb, 0xeb, 0xe3, 0xa0, 0xcb, 0x26, 0xe8, 0xfe, 0xc5, 0x41, 0x1f, 0x1b, 0x39, 0x4b,
-	0x63, 0xcd, 0x04, 0x77, 0x81, 0x5d, 0x1b, 0x61, 0xab, 0xc1, 0x37, 0xb4, 0xd6, 0xcc, 0x89, 0x43,
-	0xb4, 0x21, 0xbe, 0x72, 0x90, 0x11, 0xcb, 0xdc, 0x82, 0xd7, 0x4f, 0xa5, 0x36, 0xfc, 0xc8, 0xdb,
-	0xe6, 0x7c, 0xf2, 0x9c, 0x5e, 0x31, 0xc2, 0x49, 0x86, 0x9f, 0xa0, 0x8d, 0xcf, 0x2c, 0x07, 0xcd,
-	0x0a, 0x70, 0x2b, 0x8d, 0x5a, 0x26, 0xf9, 0x20, 0x0e, 0x81, 0xbf, 0x76, 0x3a, 0x7a, 0xe2, 0xd8,
-	0xfa, 0xe1, 0xa3, 0xde, 0x31, 0x30, 0x55, 0x0a, 0xae, 0x00, 0x3f, 0x5a, 0x20, 0x7c, 0x77, 0x09,
-	0x61, 0x6b, 0x38, 0x8d, 0x78, 0xaf, 0x0d, 0xf1, 0x76, 0x2b, 0x19, 0x6b, 0xbe, 0x80, 0x31, 0x6d,
-	0x67, 0x3c, 0x5e, 0x92, 0xb4, 0x12, 0xf2, 0x43, 0x07, 0xb9, 0x87, 0x7c, 0x87, 0xb7, 0x4b, 0x7d,
-	0x96, 0xe1, 0x5b, 0xa8, 0xe3, 0x16, 0x8b, 0x0e, 0xa1, 0x36, 0x33, 0x77, 0x29, 0x72, 0xbf, 0x5e,
-	0x41, 0x1d, 0x46, 0xa8, 0x37, 0xb5, 0xd5, 0xd4, 0xf6, 0xc4, 0xfb, 0x68, 0xdd, 0x32, 0xc0, 0xa3,
-	0x55, 0x17, 0x70, 0x70, 0x7b, 0x25, 0xc0, 0xdd, 0xe4, 0xd7, 0x7c, 0xe8, 0xfd, 0x9e, 0x0f, 0xbd,
-	0xbf, 0xf3, 0xa1, 0xf7, 0xfd, 0xdf, 0xf0, 0xd2, 0xa7, 0x9d, 0x19, 0xd3, 0x07, 0x47, 0x09, 0x49,
-	0x45, 0x11, 0x70, 0x55, 0xa6, 0xe9, 0x38, 0x83, 0x2a, 0xe0, 0x20, 0x72, 0x35, 0x8e, 0x4b, 0x36,
-	0x9e, 0x89, 0xe0, 0xcc, 0x13, 0x7c, 0xec, 0x8a, 0x9f, 0xfe, 0xb5, 0x37, 0x20, 0xf6, 0xa6, 0xe4,
-	0xe9, 0xbb, 0x49, 0xd3, 0xd2, 0x4d, 0x9e, 0xac, 0x9b, 0x07, 0xf5, 0xe0, 0x7f, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x9a, 0x12, 0x33, 0x00, 0xbb, 0x03, 0x00, 0x00,
+	// 444 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0x4d, 0x6f, 0xd3, 0x30,
+	0x18, 0xc7, 0x49, 0xa8, 0x06, 0x7a, 0xda, 0x55, 0xc2, 0x42, 0xa2, 0x2a, 0x22, 0x8c, 0x89, 0x21,
+	0x0e, 0xd4, 0x91, 0xc2, 0x01, 0x0d, 0x4e, 0x0c, 0x98, 0xa8, 0xd0, 0x78, 0x71, 0x25, 0x0e, 0xbb,
+	0x54, 0x79, 0x79, 0xd2, 0x59, 0xa8, 0x71, 0xb0, 0xbd, 0x40, 0xbe, 0x09, 0x57, 0xae, 0x7c, 0x0a,
+	0x8e, 0x1c, 0xf9, 0x08, 0xa8, 0x7c, 0x11, 0x14, 0xdb, 0x43, 0xd9, 0x96, 0xad, 0xb7, 0x38, 0xfe,
+	0x3f, 0x3f, 0x3f, 0xcf, 0x4f, 0x36, 0xdc, 0xa9, 0xa2, 0x50, 0xa1, 0x52, 0x5c, 0x14, 0xe1, 0x42,
+	0x96, 0x69, 0xa8, 0x50, 0x56, 0x3c, 0x45, 0x5a, 0x4a, 0xa1, 0x05, 0xb9, 0x51, 0xa0, 0xa0, 0xb9,
+	0xa2, 0x55, 0x44, 0x5d, 0x6a, 0x3c, 0xaa, 0xa2, 0x50, 0x62, 0xae, 0x6c, 0x5c, 0xd7, 0x25, 0x2a,
+	0x1b, 0x1e, 0xdf, 0x3e, 0xcb, 0x6a, 0x6d, 0x6e, 0xff, 0xf4, 0x61, 0xf3, 0x85, 0xc4, 0x58, 0x23,
+	0xc3, 0xcf, 0xc7, 0xa8, 0x34, 0xd9, 0x85, 0x5e, 0x22, 0xb2, 0x7a, 0xe4, 0x6d, 0x79, 0x0f, 0xfb,
+	0xd1, 0x0e, 0x3d, 0x77, 0x14, 0x3d, 0x95, 0xa7, 0x7b, 0x22, 0xab, 0x99, 0x29, 0x21, 0xaf, 0xa0,
+	0xbf, 0x44, 0x1d, 0xcf, 0x8f, 0x30, 0xce, 0x50, 0x8e, 0x7c, 0x43, 0xb8, 0xdf, 0x41, 0x70, 0xb5,
+	0x07, 0xa8, 0xe3, 0xd7, 0x26, 0xcb, 0x60, 0xf9, 0xff, 0x9b, 0x7c, 0x80, 0xcd, 0x0a, 0x25, 0xcf,
+	0xeb, 0x13, 0xd0, 0x55, 0x03, 0x7a, 0x74, 0x31, 0xe8, 0x63, 0x13, 0xe7, 0x69, 0xac, 0xb9, 0x28,
+	0x1c, 0x70, 0x60, 0x11, 0x76, 0x35, 0x3e, 0x84, 0x5e, 0xd3, 0x27, 0x89, 0xe0, 0xba, 0xf8, 0x52,
+	0xa0, 0x9c, 0xf3, 0xcc, 0x0d, 0x78, 0xab, 0x45, 0x6d, 0xfc, 0xd1, 0x77, 0xcd, 0xfe, 0xf4, 0x25,
+	0xbb, 0x66, 0x82, 0xd3, 0x8c, 0x04, 0x00, 0xf8, 0xb5, 0xe4, 0xd2, 0xd0, 0xcd, 0x50, 0x3d, 0xd6,
+	0xfa, 0xb3, 0xfd, 0xdd, 0x87, 0xe1, 0x89, 0x12, 0x55, 0x8a, 0x42, 0x21, 0x79, 0x7a, 0xca, 0xe1,
+	0x83, 0x4b, 0x1c, 0xda, 0x82, 0xb6, 0xc4, 0xfd, 0x2e, 0x89, 0x3b, 0x9d, 0xb3, 0xdb, 0xe2, 0x0b,
+	0x2c, 0xb2, 0x6e, 0x8b, 0x93, 0x4b, 0x48, 0x6b, 0x35, 0x3e, 0x71, 0x1a, 0x87, 0xe0, 0x3b, 0x81,
+	0x03, 0xe6, 0xf3, 0x8c, 0xdc, 0x85, 0xbe, 0x63, 0xcd, 0x3f, 0x61, 0x6d, 0x7a, 0x1e, 0x30, 0x70,
+	0xbf, 0xde, 0x60, 0x1d, 0xcd, 0x61, 0x38, 0xb3, 0xab, 0x99, 0xbd, 0xc8, 0xe4, 0x00, 0x36, 0xac,
+	0x03, 0xb2, 0xb5, 0xee, 0x8a, 0x8d, 0xef, 0xad, 0x15, 0xb8, 0x97, 0xfc, 0x5a, 0x05, 0xde, 0xef,
+	0x55, 0xe0, 0xfd, 0x59, 0x05, 0xde, 0xb7, 0xbf, 0xc1, 0x95, 0xc3, 0xdd, 0x05, 0xd7, 0x47, 0xc7,
+	0x09, 0x4d, 0xc5, 0x32, 0x2c, 0x54, 0x99, 0xa6, 0x93, 0x0c, 0xab, 0xb0, 0x40, 0x91, 0xab, 0x49,
+	0x5c, 0xf2, 0xc9, 0x42, 0x84, 0x67, 0x1e, 0xc6, 0x33, 0xb7, 0xf8, 0xe1, 0xdf, 0x7c, 0x8b, 0x62,
+	0x7f, 0x46, 0x9f, 0xbf, 0x9f, 0x36, 0x47, 0xba, 0xce, 0x93, 0x0d, 0xf3, 0x64, 0x1e, 0xff, 0x0b,
+	0x00, 0x00, 0xff, 0xff, 0xd3, 0xaa, 0x38, 0x65, 0x9d, 0x03, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ context.Context
-var _ grpc2.ClientConn
+var _ grpc1.ClientConn
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-const _ = grpc2.SupportPackageIsVersion4
+const _ = grpc1.SupportPackageIsVersion4
 
 // SessionServiceClient is the client API for SessionService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type SessionServiceClient interface {
 	// Create opens new session between the client and the server.
-	Create(ctx context.Context, in *CreateRequest, opts ...grpc2.CallOption) (*CreateResponse, error)
+	Create(ctx context.Context, in *CreateRequest, opts ...grpc1.CallOption) (*CreateResponse, error)
 }
 
 type sessionServiceClient struct {
-	cc *grpc2.ClientConn
+	cc *grpc1.ClientConn
 }
 
-func NewSessionServiceClient(cc *grpc2.ClientConn) SessionServiceClient {
+func NewSessionServiceClient(cc *grpc1.ClientConn) SessionServiceClient {
 	return &sessionServiceClient{cc}
 }
 
-func (c *sessionServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc2.CallOption) (*CreateResponse, error) {
+func (c *sessionServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc1.CallOption) (*CreateResponse, error) {
 	out := new(CreateResponse)
 	err := c.cc.Invoke(ctx, "/neo.fs.v2.session.SessionService/Create", in, out, opts...)
 	if err != nil {
@@ -372,11 +370,11 @@ func (*UnimplementedSessionServiceServer) Create(ctx context.Context, req *Creat
 	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
 }
 
-func RegisterSessionServiceServer(s *grpc2.Server, srv SessionServiceServer) {
+func RegisterSessionServiceServer(s *grpc1.Server, srv SessionServiceServer) {
 	s.RegisterService(&_SessionService_serviceDesc, srv)
 }
 
-func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc2.UnaryServerInterceptor) (interface{}, error) {
+func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
 	in := new(CreateRequest)
 	if err := dec(in); err != nil {
 		return nil, err
@@ -384,7 +382,7 @@ func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec fu
 	if interceptor == nil {
 		return srv.(SessionServiceServer).Create(ctx, in)
 	}
-	info := &grpc2.UnaryServerInfo{
+	info := &grpc1.UnaryServerInfo{
 		Server:     srv,
 		FullMethod: "/neo.fs.v2.session.SessionService/Create",
 	}
@@ -394,16 +392,16 @@ func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
-var _SessionService_serviceDesc = grpc2.ServiceDesc{
+var _SessionService_serviceDesc = grpc1.ServiceDesc{
 	ServiceName: "neo.fs.v2.session.SessionService",
 	HandlerType: (*SessionServiceServer)(nil),
-	Methods: []grpc2.MethodDesc{
+	Methods: []grpc1.MethodDesc{
 		{
 			MethodName: "Create",
 			Handler:    _SessionService_Create_Handler,
 		},
 	},
-	Streams:  []grpc2.StreamDesc{},
+	Streams:  []grpc1.StreamDesc{},
 	Metadata: "v2/session/grpc/service.proto",
 }
 
@@ -494,17 +492,10 @@ func (m *CreateRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.Lifetime != nil {
-		{
-			size, err := m.Lifetime.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintService(dAtA, i, uint64(size))
-		}
+	if m.Expiration != 0 {
+		i = encodeVarintService(dAtA, i, uint64(m.Expiration))
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x10
 	}
 	if m.OwnerId != nil {
 		{
@@ -670,9 +661,8 @@ func (m *CreateRequest_Body) Size() (n int) {
 		l = m.OwnerId.Size()
 		n += 1 + l + sovService(uint64(l))
 	}
-	if m.Lifetime != nil {
-		l = m.Lifetime.Size()
-		n += 1 + l + sovService(uint64(l))
+	if m.Expiration != 0 {
+		n += 1 + sovService(uint64(m.Expiration))
 	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
@@ -825,7 +815,7 @@ func (m *CreateRequest) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.MetaHeader == nil {
-				m.MetaHeader = &grpc.RequestMetaHeader{}
+				m.MetaHeader = &RequestMetaHeader{}
 			}
 			if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -861,7 +851,7 @@ func (m *CreateRequest) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.VerifyHeader == nil {
-				m.VerifyHeader = &grpc.RequestVerificationHeader{}
+				m.VerifyHeader = &RequestVerificationHeader{}
 			}
 			if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -951,17 +941,17 @@ func (m *CreateRequest_Body) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.OwnerId == nil {
-				m.OwnerId = &grpc1.OwnerID{}
+				m.OwnerId = &grpc.OwnerID{}
 			}
 			if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType)
 			}
-			var msglen int
+			m.Expiration = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowService
@@ -971,28 +961,11 @@ func (m *CreateRequest_Body) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.Expiration |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthService
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthService
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Lifetime == nil {
-				m.Lifetime = &grpc.TokenLifetime{}
-			}
-			if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipService(dAtA[iNdEx:])
@@ -1113,7 +1086,7 @@ func (m *CreateResponse) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.MetaHeader == nil {
-				m.MetaHeader = &grpc.ResponseMetaHeader{}
+				m.MetaHeader = &ResponseMetaHeader{}
 			}
 			if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -1149,7 +1122,7 @@ func (m *CreateResponse) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.VerifyHeader == nil {
-				m.VerifyHeader = &grpc.ResponseVerificationHeader{}
+				m.VerifyHeader = &ResponseVerificationHeader{}
 			}
 			if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
diff --git a/v2/service/grpc/types.pb.go b/v2/session/grpc/types.pb.go
similarity index 68%
rename from v2/service/grpc/types.pb.go
rename to v2/session/grpc/types.pb.go
index 4190b29..39733a3 100644
--- a/v2/service/grpc/types.pb.go
+++ b/v2/session/grpc/types.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: v2/service/grpc/types.proto
+// source: v2/session/grpc/types.proto
 
-package service
+package session
 
 import (
 	fmt "fmt"
@@ -73,196 +73,13 @@ func (x ObjectSessionContext_Verb) String() string {
 }
 
 func (ObjectSessionContext_Verb) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{3, 0}
-}
-
-// Extended headers for Request/Response
-type XHeader struct {
-	// Key of the X-Header.
-	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
-	// Value of the X-Header.
-	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *XHeader) Reset()         { *m = XHeader{} }
-func (m *XHeader) String() string { return proto.CompactTextString(m) }
-func (*XHeader) ProtoMessage()    {}
-func (*XHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{0}
-}
-func (m *XHeader) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *XHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_XHeader.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *XHeader) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_XHeader.Merge(m, src)
-}
-func (m *XHeader) XXX_Size() int {
-	return m.Size()
-}
-func (m *XHeader) XXX_DiscardUnknown() {
-	xxx_messageInfo_XHeader.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_XHeader proto.InternalMessageInfo
-
-func (m *XHeader) GetKey() string {
-	if m != nil {
-		return m.Key
-	}
-	return ""
-}
-
-func (m *XHeader) GetValue() string {
-	if m != nil {
-		return m.Value
-	}
-	return ""
-}
-
-// Represents API version used by node.
-type Version struct {
-	// Major API version.
-	Major uint32 `protobuf:"varint,1,opt,name=major,proto3" json:"major,omitempty"`
-	// Minor API version.
-	Minor                uint32   `protobuf:"varint,2,opt,name=minor,proto3" json:"minor,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Version) Reset()         { *m = Version{} }
-func (m *Version) String() string { return proto.CompactTextString(m) }
-func (*Version) ProtoMessage()    {}
-func (*Version) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{1}
-}
-func (m *Version) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_Version.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *Version) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Version.Merge(m, src)
-}
-func (m *Version) XXX_Size() int {
-	return m.Size()
-}
-func (m *Version) XXX_DiscardUnknown() {
-	xxx_messageInfo_Version.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Version proto.InternalMessageInfo
-
-func (m *Version) GetMajor() uint32 {
-	if m != nil {
-		return m.Major
-	}
-	return 0
-}
-
-func (m *Version) GetMinor() uint32 {
-	if m != nil {
-		return m.Minor
-	}
-	return 0
-}
-
-// Lifetime parameters of the token. Filed names taken from rfc7519.
-type TokenLifetime struct {
-	// Expiration Epoch
-	Exp uint64 `protobuf:"varint,1,opt,name=exp,proto3" json:"exp,omitempty"`
-	// Not valid before Epoch
-	Nbf uint64 `protobuf:"varint,2,opt,name=nbf,proto3" json:"nbf,omitempty"`
-	// Issued at Epoch
-	Iat                  uint64   `protobuf:"varint,3,opt,name=iat,proto3" json:"iat,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *TokenLifetime) Reset()         { *m = TokenLifetime{} }
-func (m *TokenLifetime) String() string { return proto.CompactTextString(m) }
-func (*TokenLifetime) ProtoMessage()    {}
-func (*TokenLifetime) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{2}
-}
-func (m *TokenLifetime) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *TokenLifetime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_TokenLifetime.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *TokenLifetime) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TokenLifetime.Merge(m, src)
-}
-func (m *TokenLifetime) XXX_Size() int {
-	return m.Size()
-}
-func (m *TokenLifetime) XXX_DiscardUnknown() {
-	xxx_messageInfo_TokenLifetime.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TokenLifetime proto.InternalMessageInfo
-
-func (m *TokenLifetime) GetExp() uint64 {
-	if m != nil {
-		return m.Exp
-	}
-	return 0
-}
-
-func (m *TokenLifetime) GetNbf() uint64 {
-	if m != nil {
-		return m.Nbf
-	}
-	return 0
-}
-
-func (m *TokenLifetime) GetIat() uint64 {
-	if m != nil {
-		return m.Iat
-	}
-	return 0
+	return fileDescriptor_6bbc551f310b2b05, []int{0, 0}
 }
 
 // Context information for Session Tokens related to ObjectService requests
 type ObjectSessionContext struct {
 	// Verb is a type of request for which the token is issued
-	Verb ObjectSessionContext_Verb `protobuf:"varint,1,opt,name=verb,proto3,enum=neo.fs.v2.service.ObjectSessionContext_Verb" json:"verb,omitempty"`
+	Verb ObjectSessionContext_Verb `protobuf:"varint,1,opt,name=verb,proto3,enum=neo.fs.v2.session.ObjectSessionContext_Verb" json:"verb,omitempty"`
 	// Related Object address
 	Address              *grpc.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
@@ -274,7 +91,7 @@ func (m *ObjectSessionContext) Reset()         { *m = ObjectSessionContext{} }
 func (m *ObjectSessionContext) String() string { return proto.CompactTextString(m) }
 func (*ObjectSessionContext) ProtoMessage()    {}
 func (*ObjectSessionContext) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{3}
+	return fileDescriptor_6bbc551f310b2b05, []int{0}
 }
 func (m *ObjectSessionContext) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -322,17 +139,17 @@ type SessionToken struct {
 	// Session Token body
 	Body *SessionToken_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
 	// Signature is a signature of session token information
-	Signature            *Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
-	XXX_unrecognized     []byte     `json:"-"`
-	XXX_sizecache        int32      `json:"-"`
+	Signature            *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
 }
 
 func (m *SessionToken) Reset()         { *m = SessionToken{} }
 func (m *SessionToken) String() string { return proto.CompactTextString(m) }
 func (*SessionToken) ProtoMessage()    {}
 func (*SessionToken) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{4}
+	return fileDescriptor_6bbc551f310b2b05, []int{1}
 }
 func (m *SessionToken) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -368,7 +185,7 @@ func (m *SessionToken) GetBody() *SessionToken_Body {
 	return nil
 }
 
-func (m *SessionToken) GetSignature() *Signature {
+func (m *SessionToken) GetSignature() *grpc.Signature {
 	if m != nil {
 		return m.Signature
 	}
@@ -382,7 +199,7 @@ type SessionToken_Body struct {
 	// OwnerID carries identifier of the session initiator.
 	OwnerId *grpc.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
 	// Lifetime is a lifetime of the session
-	Lifetime *TokenLifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
+	Lifetime *SessionToken_Body_TokenLifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
 	// SessionKey is a public key of session key
 	SessionKey []byte `protobuf:"bytes,4,opt,name=session_key,json=sessionKey,proto3" json:"session_key,omitempty"`
 	// Carries context of the session.
@@ -399,7 +216,7 @@ func (m *SessionToken_Body) Reset()         { *m = SessionToken_Body{} }
 func (m *SessionToken_Body) String() string { return proto.CompactTextString(m) }
 func (*SessionToken_Body) ProtoMessage()    {}
 func (*SessionToken_Body) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{4, 0}
+	return fileDescriptor_6bbc551f310b2b05, []int{1, 0}
 }
 func (m *SessionToken_Body) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -461,7 +278,7 @@ func (m *SessionToken_Body) GetOwnerId() *grpc.OwnerID {
 	return nil
 }
 
-func (m *SessionToken_Body) GetLifetime() *TokenLifetime {
+func (m *SessionToken_Body) GetLifetime() *SessionToken_Body_TokenLifetime {
 	if m != nil {
 		return m.Lifetime
 	}
@@ -489,29 +306,31 @@ func (*SessionToken_Body) XXX_OneofWrappers() []interface{} {
 	}
 }
 
-// BearerToken has information about request ACL rules with limited lifetime
-type BearerToken struct {
-	// Bearer Token body
-	Body *BearerToken_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
-	// Signature of BearerToken body
-	Signature            *Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
-	XXX_unrecognized     []byte     `json:"-"`
-	XXX_sizecache        int32      `json:"-"`
+// Lifetime parameters of the token. Filed names taken from rfc7519.
+type SessionToken_Body_TokenLifetime struct {
+	// Expiration Epoch
+	Exp uint64 `protobuf:"varint,1,opt,name=exp,proto3" json:"exp,omitempty"`
+	// Not valid before Epoch
+	Nbf uint64 `protobuf:"varint,2,opt,name=nbf,proto3" json:"nbf,omitempty"`
+	// Issued at Epoch
+	Iat                  uint64   `protobuf:"varint,3,opt,name=iat,proto3" json:"iat,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *BearerToken) Reset()         { *m = BearerToken{} }
-func (m *BearerToken) String() string { return proto.CompactTextString(m) }
-func (*BearerToken) ProtoMessage()    {}
-func (*BearerToken) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{5}
+func (m *SessionToken_Body_TokenLifetime) Reset()         { *m = SessionToken_Body_TokenLifetime{} }
+func (m *SessionToken_Body_TokenLifetime) String() string { return proto.CompactTextString(m) }
+func (*SessionToken_Body_TokenLifetime) ProtoMessage()    {}
+func (*SessionToken_Body_TokenLifetime) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6bbc551f310b2b05, []int{1, 0, 0}
 }
-func (m *BearerToken) XXX_Unmarshal(b []byte) error {
+func (m *SessionToken_Body_TokenLifetime) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *BearerToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *SessionToken_Body_TokenLifetime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_BearerToken.Marshal(b, m, deterministic)
+		return xxx_messageInfo_SessionToken_Body_TokenLifetime.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -521,57 +340,62 @@ func (m *BearerToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
-func (m *BearerToken) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BearerToken.Merge(m, src)
+func (m *SessionToken_Body_TokenLifetime) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SessionToken_Body_TokenLifetime.Merge(m, src)
 }
-func (m *BearerToken) XXX_Size() int {
+func (m *SessionToken_Body_TokenLifetime) XXX_Size() int {
 	return m.Size()
 }
-func (m *BearerToken) XXX_DiscardUnknown() {
-	xxx_messageInfo_BearerToken.DiscardUnknown(m)
+func (m *SessionToken_Body_TokenLifetime) XXX_DiscardUnknown() {
+	xxx_messageInfo_SessionToken_Body_TokenLifetime.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_BearerToken proto.InternalMessageInfo
+var xxx_messageInfo_SessionToken_Body_TokenLifetime proto.InternalMessageInfo
 
-func (m *BearerToken) GetBody() *BearerToken_Body {
+func (m *SessionToken_Body_TokenLifetime) GetExp() uint64 {
 	if m != nil {
-		return m.Body
+		return m.Exp
 	}
-	return nil
+	return 0
 }
 
-func (m *BearerToken) GetSignature() *Signature {
+func (m *SessionToken_Body_TokenLifetime) GetNbf() uint64 {
 	if m != nil {
-		return m.Signature
+		return m.Nbf
 	}
-	return nil
+	return 0
 }
 
-// Bearer Token body
-type BearerToken_Body struct {
-	// EACLTable carries table of extended ACL rules
-	EaclTable *grpc1.EACLTable `protobuf:"bytes,1,opt,name=eacl_table,json=eaclTable,proto3" json:"eacl_table,omitempty"`
-	// OwnerID carries identifier of the token owner
-	OwnerId *grpc.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
-	// Token expiration and valid time period parameters
-	Lifetime             *TokenLifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+func (m *SessionToken_Body_TokenLifetime) GetIat() uint64 {
+	if m != nil {
+		return m.Iat
+	}
+	return 0
 }
 
-func (m *BearerToken_Body) Reset()         { *m = BearerToken_Body{} }
-func (m *BearerToken_Body) String() string { return proto.CompactTextString(m) }
-func (*BearerToken_Body) ProtoMessage()    {}
-func (*BearerToken_Body) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{5, 0}
+// Extended headers for Request/Response
+type XHeader struct {
+	// Key of the X-Header.
+	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// Value of the X-Header.
+	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
-func (m *BearerToken_Body) XXX_Unmarshal(b []byte) error {
+
+func (m *XHeader) Reset()         { *m = XHeader{} }
+func (m *XHeader) String() string { return proto.CompactTextString(m) }
+func (*XHeader) ProtoMessage()    {}
+func (*XHeader) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6bbc551f310b2b05, []int{2}
+}
+func (m *XHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *BearerToken_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *XHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_BearerToken_Body.Marshal(b, m, deterministic)
+		return xxx_messageInfo_XHeader.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -581,43 +405,36 @@ func (m *BearerToken_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
-func (m *BearerToken_Body) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BearerToken_Body.Merge(m, src)
+func (m *XHeader) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_XHeader.Merge(m, src)
 }
-func (m *BearerToken_Body) XXX_Size() int {
+func (m *XHeader) XXX_Size() int {
 	return m.Size()
 }
-func (m *BearerToken_Body) XXX_DiscardUnknown() {
-	xxx_messageInfo_BearerToken_Body.DiscardUnknown(m)
+func (m *XHeader) XXX_DiscardUnknown() {
+	xxx_messageInfo_XHeader.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_BearerToken_Body proto.InternalMessageInfo
+var xxx_messageInfo_XHeader proto.InternalMessageInfo
 
-func (m *BearerToken_Body) GetEaclTable() *grpc1.EACLTable {
+func (m *XHeader) GetKey() string {
 	if m != nil {
-		return m.EaclTable
+		return m.Key
 	}
-	return nil
+	return ""
 }
 
-func (m *BearerToken_Body) GetOwnerId() *grpc.OwnerID {
+func (m *XHeader) GetValue() string {
 	if m != nil {
-		return m.OwnerId
+		return m.Value
 	}
-	return nil
-}
-
-func (m *BearerToken_Body) GetLifetime() *TokenLifetime {
-	if m != nil {
-		return m.Lifetime
-	}
-	return nil
+	return ""
 }
 
 // Information about the request
 type RequestMetaHeader struct {
 	// Client API version.
-	Version *Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
+	Version *grpc.Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
 	// Client local epoch number. Set to 0 if unknown.
 	Epoch uint64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
 	// Maximum number of nodes in the request route.
@@ -627,7 +444,7 @@ type RequestMetaHeader struct {
 	// Token is a token of the session within which the request is sent
 	SessionToken *SessionToken `protobuf:"bytes,5,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
 	// Bearer is a Bearer token of the request
-	BearerToken *BearerToken `protobuf:"bytes,6,opt,name=bearer_token,json=bearerToken,proto3" json:"bearer_token,omitempty"`
+	BearerToken *grpc1.BearerToken `protobuf:"bytes,6,opt,name=bearer_token,json=bearerToken,proto3" json:"bearer_token,omitempty"`
 	// RequestMetaHeader of the origin request.
 	Origin               *RequestMetaHeader `protobuf:"bytes,7,opt,name=origin,proto3" json:"origin,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
@@ -639,7 +456,7 @@ func (m *RequestMetaHeader) Reset()         { *m = RequestMetaHeader{} }
 func (m *RequestMetaHeader) String() string { return proto.CompactTextString(m) }
 func (*RequestMetaHeader) ProtoMessage()    {}
 func (*RequestMetaHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{6}
+	return fileDescriptor_6bbc551f310b2b05, []int{3}
 }
 func (m *RequestMetaHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -668,7 +485,7 @@ func (m *RequestMetaHeader) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_RequestMetaHeader proto.InternalMessageInfo
 
-func (m *RequestMetaHeader) GetVersion() *Version {
+func (m *RequestMetaHeader) GetVersion() *grpc.Version {
 	if m != nil {
 		return m.Version
 	}
@@ -703,7 +520,7 @@ func (m *RequestMetaHeader) GetSessionToken() *SessionToken {
 	return nil
 }
 
-func (m *RequestMetaHeader) GetBearerToken() *BearerToken {
+func (m *RequestMetaHeader) GetBearerToken() *grpc1.BearerToken {
 	if m != nil {
 		return m.BearerToken
 	}
@@ -720,7 +537,7 @@ func (m *RequestMetaHeader) GetOrigin() *RequestMetaHeader {
 // Information about the response
 type ResponseMetaHeader struct {
 	// Server API version.
-	Version *Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
+	Version *grpc.Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
 	// Server local epoch number.
 	Epoch uint64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
 	// Maximum number of nodes in the response route.
@@ -738,7 +555,7 @@ func (m *ResponseMetaHeader) Reset()         { *m = ResponseMetaHeader{} }
 func (m *ResponseMetaHeader) String() string { return proto.CompactTextString(m) }
 func (*ResponseMetaHeader) ProtoMessage()    {}
 func (*ResponseMetaHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{7}
+	return fileDescriptor_6bbc551f310b2b05, []int{4}
 }
 func (m *ResponseMetaHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -767,7 +584,7 @@ func (m *ResponseMetaHeader) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ResponseMetaHeader proto.InternalMessageInfo
 
-func (m *ResponseMetaHeader) GetVersion() *Version {
+func (m *ResponseMetaHeader) GetVersion() *grpc.Version {
 	if m != nil {
 		return m.Version
 	}
@@ -802,72 +619,14 @@ func (m *ResponseMetaHeader) GetOrigin() *ResponseMetaHeader {
 	return nil
 }
 
-// Signature of something in NeoFS
-type Signature struct {
-	// Public key used for signing.
-	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
-	// Signature
-	Sign                 []byte   `protobuf:"bytes,2,opt,name=sign,proto3" json:"sign,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Signature) Reset()         { *m = Signature{} }
-func (m *Signature) String() string { return proto.CompactTextString(m) }
-func (*Signature) ProtoMessage()    {}
-func (*Signature) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{8}
-}
-func (m *Signature) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Signature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_Signature.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *Signature) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Signature.Merge(m, src)
-}
-func (m *Signature) XXX_Size() int {
-	return m.Size()
-}
-func (m *Signature) XXX_DiscardUnknown() {
-	xxx_messageInfo_Signature.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Signature proto.InternalMessageInfo
-
-func (m *Signature) GetKey() []byte {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func (m *Signature) GetSign() []byte {
-	if m != nil {
-		return m.Sign
-	}
-	return nil
-}
-
 // Verification info for request signed by all intermediate nodes
 type RequestVerificationHeader struct {
 	// Request Body signature. Should be generated once by request initiator.
-	BodySignature *Signature `protobuf:"bytes,1,opt,name=body_signature,json=bodySignature,proto3" json:"body_signature,omitempty"`
+	BodySignature *grpc.Signature `protobuf:"bytes,1,opt,name=body_signature,json=bodySignature,proto3" json:"body_signature,omitempty"`
 	// Request Meta signature is added and signed by any intermediate node
-	MetaSignature *Signature `protobuf:"bytes,2,opt,name=meta_signature,json=metaSignature,proto3" json:"meta_signature,omitempty"`
+	MetaSignature *grpc.Signature `protobuf:"bytes,2,opt,name=meta_signature,json=metaSignature,proto3" json:"meta_signature,omitempty"`
 	// Sign previous hops
-	OriginSignature *Signature `protobuf:"bytes,3,opt,name=origin_signature,json=originSignature,proto3" json:"origin_signature,omitempty"`
+	OriginSignature *grpc.Signature `protobuf:"bytes,3,opt,name=origin_signature,json=originSignature,proto3" json:"origin_signature,omitempty"`
 	// Chain of previous hops signatures
 	Origin               *RequestVerificationHeader `protobuf:"bytes,4,opt,name=origin,proto3" json:"origin,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
@@ -879,7 +638,7 @@ func (m *RequestVerificationHeader) Reset()         { *m = RequestVerificationHe
 func (m *RequestVerificationHeader) String() string { return proto.CompactTextString(m) }
 func (*RequestVerificationHeader) ProtoMessage()    {}
 func (*RequestVerificationHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{9}
+	return fileDescriptor_6bbc551f310b2b05, []int{5}
 }
 func (m *RequestVerificationHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -908,21 +667,21 @@ func (m *RequestVerificationHeader) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_RequestVerificationHeader proto.InternalMessageInfo
 
-func (m *RequestVerificationHeader) GetBodySignature() *Signature {
+func (m *RequestVerificationHeader) GetBodySignature() *grpc.Signature {
 	if m != nil {
 		return m.BodySignature
 	}
 	return nil
 }
 
-func (m *RequestVerificationHeader) GetMetaSignature() *Signature {
+func (m *RequestVerificationHeader) GetMetaSignature() *grpc.Signature {
 	if m != nil {
 		return m.MetaSignature
 	}
 	return nil
 }
 
-func (m *RequestVerificationHeader) GetOriginSignature() *Signature {
+func (m *RequestVerificationHeader) GetOriginSignature() *grpc.Signature {
 	if m != nil {
 		return m.OriginSignature
 	}
@@ -939,11 +698,11 @@ func (m *RequestVerificationHeader) GetOrigin() *RequestVerificationHeader {
 // Verification info for response signed by all intermediate nodes
 type ResponseVerificationHeader struct {
 	// Response Body signature. Should be generated once by answering node.
-	BodySignature *Signature `protobuf:"bytes,1,opt,name=body_signature,json=bodySignature,proto3" json:"body_signature,omitempty"`
+	BodySignature *grpc.Signature `protobuf:"bytes,1,opt,name=body_signature,json=bodySignature,proto3" json:"body_signature,omitempty"`
 	// Response Meta signature is added and signed by any intermediate node
-	MetaSignature *Signature `protobuf:"bytes,2,opt,name=meta_signature,json=metaSignature,proto3" json:"meta_signature,omitempty"`
+	MetaSignature *grpc.Signature `protobuf:"bytes,2,opt,name=meta_signature,json=metaSignature,proto3" json:"meta_signature,omitempty"`
 	// Sign previous hops
-	OriginSignature *Signature `protobuf:"bytes,3,opt,name=origin_signature,json=originSignature,proto3" json:"origin_signature,omitempty"`
+	OriginSignature *grpc.Signature `protobuf:"bytes,3,opt,name=origin_signature,json=originSignature,proto3" json:"origin_signature,omitempty"`
 	// Chain of previous hops signatures
 	Origin               *ResponseVerificationHeader `protobuf:"bytes,4,opt,name=origin,proto3" json:"origin,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
@@ -955,7 +714,7 @@ func (m *ResponseVerificationHeader) Reset()         { *m = ResponseVerification
 func (m *ResponseVerificationHeader) String() string { return proto.CompactTextString(m) }
 func (*ResponseVerificationHeader) ProtoMessage()    {}
 func (*ResponseVerificationHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_006ebe254dc218a3, []int{10}
+	return fileDescriptor_6bbc551f310b2b05, []int{6}
 }
 func (m *ResponseVerificationHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -984,21 +743,21 @@ func (m *ResponseVerificationHeader) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ResponseVerificationHeader proto.InternalMessageInfo
 
-func (m *ResponseVerificationHeader) GetBodySignature() *Signature {
+func (m *ResponseVerificationHeader) GetBodySignature() *grpc.Signature {
 	if m != nil {
 		return m.BodySignature
 	}
 	return nil
 }
 
-func (m *ResponseVerificationHeader) GetMetaSignature() *Signature {
+func (m *ResponseVerificationHeader) GetMetaSignature() *grpc.Signature {
 	if m != nil {
 		return m.MetaSignature
 	}
 	return nil
 }
 
-func (m *ResponseVerificationHeader) GetOriginSignature() *Signature {
+func (m *ResponseVerificationHeader) GetOriginSignature() *grpc.Signature {
 	if m != nil {
 		return m.OriginSignature
 	}
@@ -1013,205 +772,75 @@ func (m *ResponseVerificationHeader) GetOrigin() *ResponseVerificationHeader {
 }
 
 func init() {
-	proto.RegisterEnum("neo.fs.v2.service.ObjectSessionContext_Verb", ObjectSessionContext_Verb_name, ObjectSessionContext_Verb_value)
-	proto.RegisterType((*XHeader)(nil), "neo.fs.v2.service.XHeader")
-	proto.RegisterType((*Version)(nil), "neo.fs.v2.service.Version")
-	proto.RegisterType((*TokenLifetime)(nil), "neo.fs.v2.service.TokenLifetime")
-	proto.RegisterType((*ObjectSessionContext)(nil), "neo.fs.v2.service.ObjectSessionContext")
-	proto.RegisterType((*SessionToken)(nil), "neo.fs.v2.service.SessionToken")
-	proto.RegisterType((*SessionToken_Body)(nil), "neo.fs.v2.service.SessionToken.Body")
-	proto.RegisterType((*BearerToken)(nil), "neo.fs.v2.service.BearerToken")
-	proto.RegisterType((*BearerToken_Body)(nil), "neo.fs.v2.service.BearerToken.Body")
-	proto.RegisterType((*RequestMetaHeader)(nil), "neo.fs.v2.service.RequestMetaHeader")
-	proto.RegisterType((*ResponseMetaHeader)(nil), "neo.fs.v2.service.ResponseMetaHeader")
-	proto.RegisterType((*Signature)(nil), "neo.fs.v2.service.Signature")
-	proto.RegisterType((*RequestVerificationHeader)(nil), "neo.fs.v2.service.RequestVerificationHeader")
-	proto.RegisterType((*ResponseVerificationHeader)(nil), "neo.fs.v2.service.ResponseVerificationHeader")
+	proto.RegisterEnum("neo.fs.v2.session.ObjectSessionContext_Verb", ObjectSessionContext_Verb_name, ObjectSessionContext_Verb_value)
+	proto.RegisterType((*ObjectSessionContext)(nil), "neo.fs.v2.session.ObjectSessionContext")
+	proto.RegisterType((*SessionToken)(nil), "neo.fs.v2.session.SessionToken")
+	proto.RegisterType((*SessionToken_Body)(nil), "neo.fs.v2.session.SessionToken.Body")
+	proto.RegisterType((*SessionToken_Body_TokenLifetime)(nil), "neo.fs.v2.session.SessionToken.Body.TokenLifetime")
+	proto.RegisterType((*XHeader)(nil), "neo.fs.v2.session.XHeader")
+	proto.RegisterType((*RequestMetaHeader)(nil), "neo.fs.v2.session.RequestMetaHeader")
+	proto.RegisterType((*ResponseMetaHeader)(nil), "neo.fs.v2.session.ResponseMetaHeader")
+	proto.RegisterType((*RequestVerificationHeader)(nil), "neo.fs.v2.session.RequestVerificationHeader")
+	proto.RegisterType((*ResponseVerificationHeader)(nil), "neo.fs.v2.session.ResponseVerificationHeader")
 }
 
-func init() { proto.RegisterFile("v2/service/grpc/types.proto", fileDescriptor_006ebe254dc218a3) }
+func init() { proto.RegisterFile("v2/session/grpc/types.proto", fileDescriptor_6bbc551f310b2b05) }
 
-var fileDescriptor_006ebe254dc218a3 = []byte{
-	// 943 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0xcd, 0x6e, 0x23, 0x45,
-	0x10, 0xce, 0x8c, 0x27, 0x76, 0x5c, 0xb6, 0xc3, 0x6c, 0x2b, 0xd2, 0x1a, 0x83, 0xbc, 0xd1, 0x00,
-	0x82, 0xc3, 0x66, 0xac, 0x18, 0x50, 0xf8, 0x59, 0x24, 0xfc, 0x33, 0x1b, 0x5b, 0x84, 0x6c, 0xd4,
-	0xf6, 0x46, 0x88, 0x8b, 0x35, 0x3f, 0x65, 0x67, 0xb2, 0xce, 0xb4, 0x99, 0x99, 0x0c, 0xc9, 0x9b,
-	0xf0, 0x0c, 0xdc, 0x90, 0xd0, 0x3e, 0x03, 0x47, 0x1e, 0x01, 0x85, 0x1b, 0x37, 0x4e, 0x7b, 0x43,
-	0xa8, 0x7b, 0xda, 0x3f, 0x1b, 0xdb, 0x4b, 0x90, 0x10, 0x42, 0xe2, 0x56, 0x5d, 0x5d, 0xdf, 0x37,
-	0x55, 0x5f, 0x57, 0x95, 0x0d, 0x6f, 0x24, 0xf5, 0x5a, 0x84, 0x61, 0xe2, 0xbb, 0x58, 0x1b, 0x85,
-	0x13, 0xb7, 0x16, 0x5f, 0x4f, 0x30, 0x32, 0x27, 0x21, 0x8b, 0x19, 0xb9, 0x17, 0x20, 0x33, 0x87,
-	0x91, 0x99, 0xd4, 0x4d, 0x19, 0x53, 0xb9, 0x9f, 0xd4, 0x6b, 0xb6, 0x3b, 0x5e, 0x8a, 0xad, 0x94,
-	0x93, 0x7a, 0x2d, 0xc4, 0x61, 0xb4, 0x74, 0x63, 0xec, 0x43, 0xee, 0xab, 0x0e, 0xda, 0x1e, 0x86,
-	0x44, 0x87, 0xcc, 0x33, 0xbc, 0x2e, 0x2b, 0xbb, 0xca, 0x7b, 0x79, 0xca, 0x4d, 0xb2, 0x03, 0x9b,
-	0x89, 0x3d, 0xbe, 0xc4, 0xb2, 0x2a, 0x7c, 0xe9, 0xc1, 0xf8, 0x10, 0x72, 0xa7, 0x18, 0x46, 0x3e,
-	0x0b, 0x78, 0xc0, 0x85, 0x7d, 0xce, 0x42, 0x01, 0x2a, 0xd1, 0xf4, 0x20, 0xbc, 0x7e, 0xc0, 0x42,
-	0x01, 0xe3, 0x5e, 0x7e, 0x30, 0x2c, 0x28, 0xf5, 0xd9, 0x33, 0x0c, 0x8e, 0xfc, 0x21, 0xc6, 0xfe,
-	0x05, 0xf2, 0xef, 0xe1, 0xd5, 0x44, 0x40, 0x35, 0xca, 0x4d, 0xee, 0x09, 0x9c, 0xa1, 0x80, 0x69,
-	0x94, 0x9b, 0xdc, 0xe3, 0xdb, 0x71, 0x39, 0x93, 0x7a, 0x7c, 0x3b, 0x36, 0x5e, 0x28, 0xb0, 0xf3,
-	0xc4, 0x39, 0x47, 0x37, 0xee, 0x61, 0xc4, 0x93, 0x68, 0xb1, 0x20, 0xc6, 0xab, 0x98, 0x7c, 0x0e,
-	0x5a, 0x82, 0xa1, 0x23, 0xf8, 0xb6, 0xeb, 0x0f, 0xcd, 0x25, 0x79, 0xcc, 0x55, 0x30, 0xf3, 0x14,
-	0x43, 0x87, 0x0a, 0x24, 0xd9, 0x87, 0x9c, 0xed, 0x79, 0x21, 0x46, 0x91, 0x48, 0xa1, 0x50, 0xbf,
-	0xbf, 0x40, 0xc2, 0xe5, 0x33, 0x1b, 0xe9, 0x35, 0x9d, 0xc6, 0x19, 0xe7, 0xa0, 0x71, 0x02, 0xb2,
-	0x03, 0xfa, 0xa9, 0x45, 0x9b, 0x83, 0xa7, 0xc7, 0xbd, 0x13, 0xab, 0xd5, 0x7d, 0xdc, 0xb5, 0xda,
-	0xfa, 0x06, 0xc9, 0x41, 0xe6, 0xe4, 0x69, 0x5f, 0x57, 0xb8, 0x71, 0x68, 0xf5, 0x75, 0x95, 0x6c,
-	0x81, 0xd6, 0xb1, 0x1a, 0x6d, 0x3d, 0x43, 0x00, 0xb2, 0x3d, 0xab, 0x41, 0x5b, 0x1d, 0x5d, 0xe3,
-	0x76, 0xdb, 0x3a, 0xb2, 0xfa, 0x96, 0xbe, 0x49, 0xf2, 0xb0, 0x49, 0x1b, 0xc7, 0x87, 0x96, 0x9e,
-	0x25, 0x25, 0xc8, 0x0b, 0xb3, 0xd3, 0xe8, 0x75, 0xf4, 0x9c, 0xf1, 0x87, 0x0a, 0x45, 0x99, 0xbc,
-	0x10, 0x92, 0x7c, 0x04, 0x9a, 0xc3, 0xbc, 0xf4, 0xc5, 0x0a, 0xf5, 0xb7, 0x57, 0x54, 0xbc, 0x18,
-	0x6e, 0x36, 0x99, 0x77, 0x4d, 0x05, 0x82, 0x7c, 0x02, 0xf9, 0xc8, 0x1f, 0x05, 0x76, 0x7c, 0x19,
-	0xa2, 0xac, 0xf5, 0xcd, 0x55, 0xf0, 0x69, 0x0c, 0x9d, 0x87, 0x57, 0x5e, 0x28, 0xa0, 0x71, 0x2a,
-	0xb2, 0x0d, 0xaa, 0xef, 0x89, 0x8f, 0x17, 0xa9, 0xea, 0x7b, 0xa4, 0x0e, 0x5b, 0xec, 0xdb, 0x00,
-	0xc3, 0x81, 0xef, 0xad, 0xd3, 0xef, 0x09, 0xbf, 0xef, 0xb6, 0x69, 0x4e, 0x04, 0x76, 0x3d, 0xf2,
-	0x08, 0xb6, 0xc6, 0xb2, 0x1f, 0xc4, 0x23, 0x17, 0xea, 0xbb, 0x2b, 0xf2, 0x78, 0xa9, 0x6f, 0xe8,
-	0x0c, 0x41, 0x1e, 0x40, 0x21, 0x4a, 0x2b, 0x1c, 0xf0, 0xce, 0xd5, 0x44, 0x2a, 0x20, 0x5d, 0x5f,
-	0xe0, 0x35, 0x69, 0x40, 0x96, 0x89, 0x47, 0x2f, 0x6f, 0x0a, 0xf2, 0x77, 0xef, 0xd8, 0x15, 0x9d,
-	0x0d, 0x2a, 0x81, 0xcd, 0x3c, 0xe4, 0xdc, 0xd4, 0x69, 0x3c, 0x57, 0xa1, 0xd0, 0x44, 0x3b, 0xc4,
-	0x30, 0xd5, 0xff, 0xe0, 0x25, 0xfd, 0xdf, 0x5a, 0xc1, 0xbd, 0x10, 0xfd, 0x4f, 0xc9, 0xff, 0xc3,
-	0x54, 0xfe, 0x03, 0x00, 0xb4, 0xdd, 0xf1, 0x20, 0xb6, 0x9d, 0x31, 0xca, 0x1c, 0xca, 0x0b, 0x2c,
-	0xb6, 0x3b, 0x36, 0xad, 0x46, 0xeb, 0xa8, 0xcf, 0xef, 0x69, 0x9e, 0xc7, 0x0a, 0xf3, 0xdf, 0x7f,
-	0x27, 0xe3, 0x77, 0x15, 0xee, 0x51, 0xfc, 0xe6, 0x12, 0xa3, 0xf8, 0x4b, 0x8c, 0x6d, 0xb9, 0x6f,
-	0x3e, 0x80, 0x5c, 0x92, 0xee, 0x11, 0x99, 0x7d, 0x65, 0x05, 0xa5, 0xdc, 0x34, 0x74, 0x1a, 0xca,
-	0x97, 0x0b, 0x4e, 0x98, 0x7b, 0x26, 0xb7, 0x44, 0x7a, 0xe0, 0x7b, 0x22, 0x8e, 0xc7, 0x22, 0xb5,
-	0x12, 0xe5, 0x26, 0x39, 0x80, 0xfc, 0xd5, 0xe0, 0x4c, 0x7c, 0x29, 0x2a, 0x6b, 0xbb, 0x99, 0x35,
-	0xfc, 0x72, 0xf9, 0xd1, 0xad, 0xab, 0xd4, 0x88, 0x48, 0x1b, 0x4a, 0xd3, 0xa6, 0x8a, 0x79, 0x3d,
-	0xb2, 0x75, 0x1e, 0xfc, 0xc5, 0x78, 0xd1, 0x62, 0xb4, 0x38, 0x9b, 0x0d, 0x28, 0x3a, 0xe2, 0xf1,
-	0x25, 0x49, 0x56, 0x90, 0x54, 0x5f, 0xdd, 0x23, 0xb4, 0xe0, 0x2c, 0xb4, 0xd7, 0x23, 0xc8, 0xb2,
-	0xd0, 0x1f, 0xf9, 0x41, 0x39, 0xb7, 0x76, 0xc0, 0x97, 0x54, 0xa5, 0x12, 0x63, 0xfc, 0xa6, 0x00,
-	0xa1, 0x18, 0x4d, 0x58, 0x10, 0xe1, 0x7f, 0x5f, 0xf4, 0xcf, 0x66, 0xb5, 0xa6, 0x6a, 0xbf, 0xb3,
-	0xb2, 0xd6, 0xdb, 0xd5, 0xcc, 0x8a, 0xdd, 0x87, 0xfc, 0x6c, 0x58, 0x16, 0x7f, 0xc7, 0x8a, 0xe9,
-	0xef, 0x18, 0x01, 0x8d, 0x0f, 0x90, 0xc8, 0xbe, 0x48, 0x85, 0x6d, 0xfc, 0xa8, 0xc2, 0xeb, 0x52,
-	0xbd, 0x53, 0x0c, 0xfd, 0xa1, 0xef, 0xda, 0xb1, 0xcf, 0x02, 0x29, 0x53, 0x0b, 0xb6, 0xf9, 0xa4,
-	0x0e, 0xe6, 0x63, 0xaa, 0xdc, 0x61, 0x4c, 0x4b, 0x1c, 0x33, 0x4f, 0xa4, 0x05, 0xdb, 0x17, 0x18,
-	0xdb, 0x83, 0xbf, 0x37, 0xeb, 0x25, 0x8e, 0x99, 0x93, 0x1c, 0x82, 0x9e, 0x16, 0xb9, 0x40, 0x93,
-	0xb9, 0x03, 0xcd, 0x6b, 0x29, 0x6a, 0x4e, 0xd4, 0x9e, 0x49, 0xac, 0x09, 0xf8, 0xc3, 0xf5, 0xed,
-	0xb4, 0x2c, 0xc8, 0x4c, 0xe9, 0xe7, 0x2a, 0x54, 0xa6, 0x0f, 0xf1, 0xff, 0xd0, 0xcd, 0xba, 0xa5,
-	0xdb, 0xde, 0x2b, 0x5a, 0x73, 0xbd, 0x70, 0x4d, 0xe7, 0xa7, 0x9b, 0xaa, 0xf2, 0xf3, 0x4d, 0x55,
-	0xf9, 0xe5, 0xa6, 0xaa, 0x7c, 0xf7, 0x6b, 0x75, 0xe3, 0xeb, 0x8f, 0x47, 0x7e, 0x7c, 0x76, 0xe9,
-	0x98, 0x2e, 0xbb, 0xa8, 0x05, 0xd1, 0xc4, 0x75, 0xf7, 0x3c, 0x4c, 0x6a, 0x01, 0xb2, 0x61, 0xb4,
-	0x67, 0x4f, 0xfc, 0xbd, 0x11, 0xab, 0xdd, 0xfa, 0xff, 0xf7, 0xa9, 0x3c, 0x7c, 0xaf, 0xee, 0x1c,
-	0x23, 0x7b, 0xdc, 0x33, 0x1b, 0x27, 0x5d, 0x9e, 0x46, 0x2f, 0x75, 0x3b, 0x59, 0xf1, 0x9f, 0xee,
-	0xfd, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x0c, 0x60, 0x03, 0xc2, 0x38, 0x0a, 0x00, 0x00,
-}
-
-func (m *XHeader) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *XHeader) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *XHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Value) > 0 {
-		i -= len(m.Value)
-		copy(dAtA[i:], m.Value)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Value)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Key) > 0 {
-		i -= len(m.Key)
-		copy(dAtA[i:], m.Key)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Version) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Version) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Version) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.Minor != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.Minor))
-		i--
-		dAtA[i] = 0x10
-	}
-	if m.Major != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.Major))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *TokenLifetime) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *TokenLifetime) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TokenLifetime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.Iat != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.Iat))
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.Nbf != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.Nbf))
-		i--
-		dAtA[i] = 0x10
-	}
-	if m.Exp != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.Exp))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
+var fileDescriptor_6bbc551f310b2b05 = []byte{
+	// 840 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x56, 0xdd, 0x6e, 0x1b, 0x45,
+	0x14, 0xce, 0xae, 0x37, 0x76, 0x7c, 0x1c, 0x87, 0xed, 0x28, 0x52, 0x5d, 0x23, 0xa5, 0x91, 0x05,
+	0x22, 0x17, 0xcd, 0x5a, 0x59, 0x2e, 0x00, 0x41, 0xa5, 0xda, 0xf1, 0xb6, 0xb6, 0x28, 0x69, 0x34,
+	0x4e, 0x23, 0xc4, 0x8d, 0xb5, 0x3f, 0xc7, 0xce, 0xb6, 0xce, 0x8e, 0xd9, 0x99, 0x2c, 0xf1, 0x9b,
+	0xf0, 0x0c, 0x20, 0xde, 0x83, 0xcb, 0x5e, 0xf0, 0x00, 0x28, 0x5c, 0x20, 0xf1, 0x02, 0xdc, 0xa2,
+	0x99, 0x1d, 0x3b, 0x26, 0x8e, 0x49, 0xb8, 0x43, 0xdc, 0x9d, 0xd9, 0x39, 0xdf, 0x37, 0xdf, 0xf7,
+	0xcd, 0xf1, 0xc8, 0xf0, 0x7e, 0xe6, 0x36, 0x39, 0x72, 0x1e, 0xb3, 0xa4, 0x39, 0x4a, 0x27, 0x61,
+	0x53, 0x4c, 0x27, 0xc8, 0x9d, 0x49, 0xca, 0x04, 0x23, 0x0f, 0x12, 0x64, 0xce, 0x90, 0x3b, 0x99,
+	0xeb, 0xe8, 0x9e, 0x7a, 0x2d, 0x73, 0x9b, 0x29, 0x0e, 0xf9, 0x52, 0x73, 0xfd, 0x61, 0xe6, 0x36,
+	0xfd, 0x70, 0xbc, 0xb4, 0xd1, 0xf8, 0xd3, 0x80, 0xed, 0x57, 0xc1, 0x1b, 0x0c, 0x45, 0x3f, 0x27,
+	0x39, 0x64, 0x89, 0xc0, 0x4b, 0x41, 0x9e, 0x81, 0x95, 0x61, 0x1a, 0xd4, 0x8c, 0x5d, 0x63, 0x6f,
+	0xcb, 0x7d, 0xe2, 0x2c, 0x9d, 0xe6, 0xdc, 0x06, 0x73, 0x4e, 0x31, 0x0d, 0xa8, 0x42, 0x92, 0x03,
+	0x28, 0xf9, 0x51, 0x94, 0x22, 0xe7, 0x35, 0x73, 0xd7, 0xd8, 0xab, 0xb8, 0x0f, 0x17, 0x48, 0xa4,
+	0x4c, 0xa7, 0x95, 0x6f, 0xd3, 0x59, 0x5f, 0xe3, 0x0d, 0x58, 0x92, 0x80, 0x6c, 0x83, 0x7d, 0xea,
+	0xd1, 0xf6, 0xe0, 0xf5, 0x51, 0xff, 0xd8, 0x3b, 0xec, 0x3d, 0xef, 0x79, 0x1d, 0x7b, 0x8d, 0x94,
+	0xa0, 0x70, 0xfc, 0xfa, 0xc4, 0x36, 0x64, 0xf1, 0xc2, 0x3b, 0xb1, 0x4d, 0xb2, 0x01, 0x56, 0xd7,
+	0x6b, 0x75, 0xec, 0x02, 0x01, 0x28, 0xf6, 0xbd, 0x16, 0x3d, 0xec, 0xda, 0x96, 0xac, 0x3b, 0xde,
+	0x4b, 0xef, 0xc4, 0xb3, 0xd7, 0x49, 0x19, 0xd6, 0x69, 0xeb, 0xe8, 0x85, 0x67, 0x17, 0x49, 0x15,
+	0xca, 0xaa, 0xec, 0xb6, 0xfa, 0x5d, 0xbb, 0xd4, 0xf8, 0xa5, 0x00, 0x9b, 0x5a, 0xfc, 0x09, 0x7b,
+	0x8b, 0x09, 0xf9, 0x14, 0xac, 0x80, 0x45, 0x53, 0xe5, 0xb8, 0xe2, 0x7e, 0x70, 0x8b, 0xe3, 0xc5,
+	0x76, 0xa7, 0xcd, 0xa2, 0x29, 0x55, 0x08, 0xf2, 0x09, 0x94, 0x79, 0x3c, 0x4a, 0x7c, 0x71, 0x91,
+	0xa2, 0xf6, 0xfa, 0xe8, 0xa6, 0xd7, 0xfe, 0xac, 0x81, 0x5e, 0xf7, 0xd6, 0xdf, 0x99, 0x60, 0x49,
+	0x1e, 0xb2, 0x05, 0x66, 0x1c, 0xa9, 0x93, 0x37, 0xa9, 0x19, 0x47, 0xc4, 0x85, 0x0d, 0xf6, 0x5d,
+	0x82, 0xe9, 0x20, 0x8e, 0x56, 0x85, 0xf7, 0x4a, 0xee, 0xf7, 0x3a, 0xb4, 0xa4, 0x1a, 0x7b, 0x11,
+	0x39, 0x82, 0x8d, 0x71, 0x3c, 0x44, 0x11, 0x9f, 0x63, 0xad, 0xa0, 0x30, 0xee, 0x7d, 0x3c, 0x38,
+	0xaa, 0x7c, 0xa9, 0x91, 0x74, 0xce, 0x41, 0x1e, 0x43, 0x45, 0x83, 0x06, 0x6f, 0x71, 0x5a, 0xb3,
+	0x94, 0x38, 0xd0, 0x9f, 0xbe, 0xc4, 0x29, 0x69, 0x41, 0x91, 0xa9, 0x19, 0xa8, 0xad, 0xab, 0xe3,
+	0x3e, 0xba, 0xe7, 0x90, 0x74, 0xd7, 0xa8, 0x06, 0xd6, 0x3d, 0xa8, 0xfe, 0xed, 0x78, 0x62, 0x43,
+	0x01, 0x2f, 0x27, 0x2a, 0x09, 0x8b, 0xca, 0x52, 0x7e, 0x49, 0x82, 0xa1, 0x4a, 0xc1, 0xa2, 0xb2,
+	0x94, 0x5f, 0x62, 0x5f, 0x28, 0x8f, 0x16, 0x95, 0x65, 0xbb, 0x0c, 0xa5, 0x30, 0xe7, 0x6e, 0x1c,
+	0x40, 0xe9, 0xeb, 0x2e, 0xfa, 0x11, 0xa6, 0xb2, 0x4f, 0x0a, 0x97, 0x5c, 0x65, 0x2a, 0x4b, 0xb2,
+	0x0d, 0xeb, 0x99, 0x3f, 0xbe, 0xc8, 0x2f, 0xa9, 0x4c, 0xf3, 0x45, 0xe3, 0x0f, 0x13, 0x1e, 0x50,
+	0xfc, 0xf6, 0x02, 0xb9, 0xf8, 0x0a, 0x85, 0xaf, 0xd1, 0x07, 0x50, 0xca, 0x30, 0x95, 0xb2, 0xf5,
+	0x44, 0x2c, 0xdd, 0xc0, 0x69, 0xbe, 0x4d, 0x67, 0x7d, 0x92, 0x1e, 0x27, 0x2c, 0x3c, 0xd3, 0x62,
+	0xf3, 0x85, 0x94, 0x21, 0xc4, 0x58, 0xc9, 0xad, 0x52, 0x59, 0xca, 0x79, 0xb9, 0x1c, 0x9c, 0xa9,
+	0x63, 0x78, 0xcd, 0xda, 0x2d, 0xec, 0x55, 0xdc, 0xfa, 0x2d, 0xd9, 0x69, 0x1f, 0x74, 0xe3, 0x32,
+	0x2f, 0x38, 0xe9, 0x40, 0x75, 0x76, 0x25, 0x42, 0xc6, 0xa6, 0x83, 0x7f, 0x7c, 0xc7, 0x3d, 0xd3,
+	0x4d, 0xbe, 0x38, 0xe8, 0x4f, 0x61, 0x33, 0x40, 0x3f, 0xc5, 0x54, 0x93, 0x14, 0x15, 0xc9, 0xa2,
+	0x02, 0x3f, 0x1c, 0x3b, 0x6d, 0xd5, 0x92, 0xe3, 0x2b, 0xc1, 0xf5, 0x82, 0x7c, 0x01, 0x45, 0x96,
+	0xc6, 0xa3, 0x38, 0xa9, 0x95, 0x56, 0xfe, 0x52, 0x96, 0xe2, 0xa4, 0x1a, 0xd3, 0xf8, 0xdd, 0x00,
+	0x42, 0x91, 0x4f, 0x58, 0xc2, 0xf1, 0x3f, 0x9e, 0xf6, 0xd3, 0xb9, 0xd1, 0x3c, 0xe6, 0x0f, 0x6f,
+	0x35, 0x7a, 0xd3, 0xca, 0xdc, 0xe9, 0x8f, 0x26, 0x3c, 0xd2, 0x39, 0x9c, 0x62, 0x1a, 0x0f, 0xe3,
+	0xd0, 0x17, 0x31, 0x4b, 0xb4, 0xe1, 0x67, 0xb0, 0x25, 0xdf, 0x8e, 0xc1, 0xf5, 0xc3, 0x61, 0xdc,
+	0xf5, 0x70, 0x54, 0x25, 0x60, 0xbe, 0x94, 0x0c, 0xe7, 0x28, 0xfc, 0xc1, 0xbf, 0x78, 0x7a, 0xaa,
+	0x12, 0x70, 0xcd, 0xd0, 0x01, 0x3b, 0xd7, 0xba, 0xc0, 0x51, 0xb8, 0x8b, 0xe3, 0xbd, 0x1c, 0xb2,
+	0xc8, 0x32, 0x8b, 0xc9, 0x52, 0xd8, 0x27, 0xab, 0xe7, 0x61, 0x39, 0x87, 0x79, 0x5a, 0x3f, 0x99,
+	0x50, 0x9f, 0x85, 0xf9, 0xbf, 0x8e, 0xcb, 0xbb, 0x11, 0xd7, 0xfe, 0x3f, 0x4c, 0xd5, 0xea, 0xbc,
+	0xda, 0xc1, 0xcf, 0x57, 0x3b, 0xc6, 0xbb, 0xab, 0x1d, 0xe3, 0xd7, 0xab, 0x1d, 0xe3, 0xfb, 0xdf,
+	0x76, 0xd6, 0xbe, 0xf9, 0x6c, 0x14, 0x8b, 0xb3, 0x8b, 0xc0, 0x09, 0xd9, 0x79, 0x33, 0xe1, 0x93,
+	0x30, 0xdc, 0x8f, 0x30, 0x6b, 0x26, 0xc8, 0x86, 0x7c, 0xdf, 0x9f, 0xc4, 0xfb, 0x23, 0xd6, 0xbc,
+	0xf1, 0x7f, 0xe2, 0x73, 0xbd, 0xf8, 0xc1, 0xdc, 0x3e, 0x42, 0xf6, 0xbc, 0xef, 0xb4, 0x8e, 0x7b,
+	0x52, 0x86, 0x7e, 0x3b, 0x82, 0xa2, 0xfa, 0x8f, 0xf0, 0xf1, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0x00, 0x73, 0x57, 0xf8, 0x88, 0x08, 0x00, 0x00,
 }
 
 func (m *ObjectSessionContext) Marshal() (dAtA []byte, err error) {
@@ -1404,7 +1033,7 @@ func (m *SessionToken_Body_Object) MarshalToSizedBuffer(dAtA []byte) (int, error
 	}
 	return len(dAtA) - i, nil
 }
-func (m *BearerToken) Marshal() (dAtA []byte, err error) {
+func (m *SessionToken_Body_TokenLifetime) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -1414,12 +1043,12 @@ func (m *BearerToken) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *BearerToken) MarshalTo(dAtA []byte) (int, error) {
+func (m *SessionToken_Body_TokenLifetime) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *BearerToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *SessionToken_Body_TokenLifetime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1428,34 +1057,25 @@ func (m *BearerToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.Signature != nil {
-		{
-			size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTypes(dAtA, i, uint64(size))
-		}
+	if m.Iat != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Iat))
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x18
 	}
-	if m.Body != nil {
-		{
-			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTypes(dAtA, i, uint64(size))
-		}
+	if m.Nbf != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Nbf))
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x10
+	}
+	if m.Exp != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Exp))
+		i--
+		dAtA[i] = 0x8
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *BearerToken_Body) Marshal() (dAtA []byte, err error) {
+func (m *XHeader) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -1465,12 +1085,12 @@ func (m *BearerToken_Body) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *BearerToken_Body) MarshalTo(dAtA []byte) (int, error) {
+func (m *XHeader) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *BearerToken_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *XHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1479,39 +1099,17 @@ func (m *BearerToken_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.Lifetime != nil {
-		{
-			size, err := m.Lifetime.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTypes(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
-	}
-	if m.OwnerId != nil {
-		{
-			size, err := m.OwnerId.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTypes(dAtA, i, uint64(size))
-		}
+	if len(m.Value) > 0 {
+		i -= len(m.Value)
+		copy(dAtA[i:], m.Value)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Value)))
 		i--
 		dAtA[i] = 0x12
 	}
-	if m.EaclTable != nil {
-		{
-			size, err := m.EaclTable.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTypes(dAtA, i, uint64(size))
-		}
+	if len(m.Key) > 0 {
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -1692,47 +1290,6 @@ func (m *ResponseMetaHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *Signature) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Signature) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Signature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Sign) > 0 {
-		i -= len(m.Sign)
-		copy(dAtA[i:], m.Sign)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sign)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Key) > 0 {
-		i -= len(m.Key)
-		copy(dAtA[i:], m.Key)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *RequestVerificationHeader) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1894,65 +1451,6 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
-func (m *XHeader) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	l = len(m.Value)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *Version) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Major != 0 {
-		n += 1 + sovTypes(uint64(m.Major))
-	}
-	if m.Minor != 0 {
-		n += 1 + sovTypes(uint64(m.Minor))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *TokenLifetime) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Exp != 0 {
-		n += 1 + sovTypes(uint64(m.Exp))
-	}
-	if m.Nbf != 0 {
-		n += 1 + sovTypes(uint64(m.Nbf))
-	}
-	if m.Iat != 0 {
-		n += 1 + sovTypes(uint64(m.Iat))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
 func (m *ObjectSessionContext) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2035,19 +1533,20 @@ func (m *SessionToken_Body_Object) Size() (n int) {
 	}
 	return n
 }
-func (m *BearerToken) Size() (n int) {
+func (m *SessionToken_Body_TokenLifetime) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Body != nil {
-		l = m.Body.Size()
-		n += 1 + l + sovTypes(uint64(l))
+	if m.Exp != 0 {
+		n += 1 + sovTypes(uint64(m.Exp))
 	}
-	if m.Signature != nil {
-		l = m.Signature.Size()
-		n += 1 + l + sovTypes(uint64(l))
+	if m.Nbf != 0 {
+		n += 1 + sovTypes(uint64(m.Nbf))
+	}
+	if m.Iat != 0 {
+		n += 1 + sovTypes(uint64(m.Iat))
 	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
@@ -2055,22 +1554,18 @@ func (m *BearerToken) Size() (n int) {
 	return n
 }
 
-func (m *BearerToken_Body) Size() (n int) {
+func (m *XHeader) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.EaclTable != nil {
-		l = m.EaclTable.Size()
+	l = len(m.Key)
+	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.OwnerId != nil {
-		l = m.OwnerId.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.Lifetime != nil {
-		l = m.Lifetime.Size()
+	l = len(m.Value)
+	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
 	if m.XXX_unrecognized != nil {
@@ -2151,26 +1646,6 @@ func (m *ResponseMetaHeader) Size() (n int) {
 	return n
 }
 
-func (m *Signature) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	l = len(m.Sign)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
 func (m *RequestVerificationHeader) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2233,327 +1708,6 @@ func sovTypes(x uint64) (n int) {
 func sozTypes(x uint64) (n int) {
 	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
-func (m *XHeader) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: XHeader: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: XHeader: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Key = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Value = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Version) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Version: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Major", wireType)
-			}
-			m.Major = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Major |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Minor", wireType)
-			}
-			m.Minor = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Minor |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *TokenLifetime) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: TokenLifetime: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TokenLifetime: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Exp", wireType)
-			}
-			m.Exp = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Exp |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Nbf", wireType)
-			}
-			m.Nbf = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Nbf |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Iat", wireType)
-			}
-			m.Iat = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Iat |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *ObjectSessionContext) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -2758,7 +1912,7 @@ func (m *SessionToken) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Signature == nil {
-				m.Signature = &Signature{}
+				m.Signature = &grpc.Signature{}
 			}
 			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -2918,7 +2072,7 @@ func (m *SessionToken_Body) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Lifetime == nil {
-				m.Lifetime = &TokenLifetime{}
+				m.Lifetime = &SessionToken_Body_TokenLifetime{}
 			}
 			if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -3018,7 +2172,7 @@ func (m *SessionToken_Body) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BearerToken) Unmarshal(dAtA []byte) error {
+func (m *SessionToken_Body_TokenLifetime) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -3041,17 +2195,17 @@ func (m *BearerToken) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: BearerToken: wiretype end group for non-group")
+			return fmt.Errorf("proto: TokenLifetime: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BearerToken: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: TokenLifetime: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Exp", wireType)
 			}
-			var msglen int
+			m.Exp = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -3061,33 +2215,16 @@ func (m *BearerToken) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.Exp |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Body == nil {
-				m.Body = &BearerToken_Body{}
-			}
-			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Nbf", wireType)
 			}
-			var msglen int
+			m.Nbf = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -3097,28 +2234,30 @@ func (m *BearerToken) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.Nbf |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Iat", wireType)
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
+			m.Iat = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Iat |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Signature == nil {
-				m.Signature = &Signature{}
-			}
-			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTypes(dAtA[iNdEx:])
@@ -3144,7 +2283,7 @@ func (m *BearerToken) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
+func (m *XHeader) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -3167,17 +2306,17 @@ func (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Body: wiretype end group for non-group")
+			return fmt.Errorf("proto: XHeader: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: XHeader: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EaclTable", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -3187,33 +2326,29 @@ func (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthTypes
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.EaclTable == nil {
-				m.EaclTable = &grpc1.EACLTable{}
-			}
-			if err := m.EaclTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Key = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OwnerId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -3223,63 +2358,23 @@ func (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthTypes
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.OwnerId == nil {
-				m.OwnerId = &grpc.OwnerID{}
-			}
-			if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Lifetime == nil {
-				m.Lifetime = &TokenLifetime{}
-			}
-			if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Value = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -3365,7 +2460,7 @@ func (m *RequestMetaHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Version == nil {
-				m.Version = &Version{}
+				m.Version = &grpc.Version{}
 			}
 			if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -3509,7 +2604,7 @@ func (m *RequestMetaHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.BearerToken == nil {
-				m.BearerToken = &BearerToken{}
+				m.BearerToken = &grpc1.BearerToken{}
 			}
 			if err := m.BearerToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -3635,7 +2730,7 @@ func (m *ResponseMetaHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Version == nil {
-				m.Version = &Version{}
+				m.Version = &grpc.Version{}
 			}
 			if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -3774,128 +2869,6 @@ func (m *ResponseMetaHeader) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Signature) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Signature: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Signature: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
-			if m.Key == nil {
-				m.Key = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Sign", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Sign = append(m.Sign[:0], dAtA[iNdEx:postIndex]...)
-			if m.Sign == nil {
-				m.Sign = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *RequestVerificationHeader) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -3955,7 +2928,7 @@ func (m *RequestVerificationHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.BodySignature == nil {
-				m.BodySignature = &Signature{}
+				m.BodySignature = &grpc.Signature{}
 			}
 			if err := m.BodySignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -3991,7 +2964,7 @@ func (m *RequestVerificationHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.MetaSignature == nil {
-				m.MetaSignature = &Signature{}
+				m.MetaSignature = &grpc.Signature{}
 			}
 			if err := m.MetaSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -4027,7 +3000,7 @@ func (m *RequestVerificationHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.OriginSignature == nil {
-				m.OriginSignature = &Signature{}
+				m.OriginSignature = &grpc.Signature{}
 			}
 			if err := m.OriginSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -4153,7 +3126,7 @@ func (m *ResponseVerificationHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.BodySignature == nil {
-				m.BodySignature = &Signature{}
+				m.BodySignature = &grpc.Signature{}
 			}
 			if err := m.BodySignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -4189,7 +3162,7 @@ func (m *ResponseVerificationHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.MetaSignature == nil {
-				m.MetaSignature = &Signature{}
+				m.MetaSignature = &grpc.Signature{}
 			}
 			if err := m.MetaSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -4225,7 +3198,7 @@ func (m *ResponseVerificationHeader) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.OriginSignature == nil {
-				m.OriginSignature = &Signature{}
+				m.OriginSignature = &grpc.Signature{}
 			}
 			if err := m.OriginSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
diff --git a/v2/storagegroup/grpc/types.pb.go b/v2/storagegroup/grpc/types.pb.go
index 91dae60..212d7ce 100644
--- a/v2/storagegroup/grpc/types.pb.go
+++ b/v2/storagegroup/grpc/types.pb.go
@@ -33,7 +33,7 @@ type StorageGroup struct {
 	// payloads of the storage group members
 	// The order of concatenation is the same as the order of the members in the
 	// Members field.
-	ValidationHash []byte `protobuf:"bytes,2,opt,name=validation_hash,json=validationHash,proto3" json:"validation_hash,omitempty"`
+	ValidationHash *grpc.Checksum `protobuf:"bytes,2,opt,name=validation_hash,json=validationHash,proto3" json:"validation_hash,omitempty"`
 	// expiration_epoch carries last NeoFS epoch number of the storage group
 	// lifetime.
 	ExpirationEpoch uint64 `protobuf:"varint,3,opt,name=expiration_epoch,json=expirationEpoch,proto3" json:"expiration_epoch,omitempty"`
@@ -85,7 +85,7 @@ func (m *StorageGroup) GetValidationDataSize() uint64 {
 	return 0
 }
 
-func (m *StorageGroup) GetValidationHash() []byte {
+func (m *StorageGroup) GetValidationHash() *grpc.Checksum {
 	if m != nil {
 		return m.ValidationHash
 	}
@@ -113,26 +113,27 @@ func init() {
 func init() { proto.RegisterFile("v2/storagegroup/grpc/types.proto", fileDescriptor_f1685cc94b670845) }
 
 var fileDescriptor_f1685cc94b670845 = []byte{
-	// 301 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xcd, 0x4a, 0x33, 0x31,
-	0x18, 0x85, 0xbf, 0xb4, 0xe5, 0x13, 0x62, 0xb1, 0x12, 0x44, 0xa2, 0x8b, 0x61, 0x70, 0x63, 0x5d,
-	0x34, 0x91, 0x71, 0xe9, 0x4a, 0xad, 0x3f, 0xdd, 0xa8, 0xb4, 0x3b, 0x37, 0x25, 0x93, 0xbe, 0x9d,
-	0x89, 0xd8, 0x49, 0x4c, 0xd2, 0x41, 0x7b, 0x25, 0x5e, 0x83, 0x57, 0xd2, 0xa5, 0x97, 0x20, 0xe3,
-	0x8d, 0xc8, 0xb4, 0xc8, 0x0c, 0xe8, 0xf6, 0xc9, 0x73, 0xf2, 0x72, 0x0e, 0x0e, 0xf3, 0x88, 0x3b,
-	0xaf, 0xad, 0x48, 0x20, 0xb1, 0x7a, 0x6e, 0x78, 0x62, 0x8d, 0xe4, 0xfe, 0xd5, 0x80, 0x63, 0xc6,
-	0x6a, 0xaf, 0xc9, 0x6e, 0x06, 0x9a, 0x4d, 0x1d, 0xcb, 0x23, 0x56, 0x17, 0xf7, 0x69, 0x1e, 0x71,
-	0x0b, 0x53, 0xf7, 0x2b, 0x71, 0xb0, 0x44, 0xb8, 0x3d, 0x5a, 0xab, 0xd7, 0xa5, 0x4a, 0x8e, 0xf1,
-	0x4e, 0x2e, 0x9e, 0xd4, 0x44, 0x78, 0xa5, 0xb3, 0xf1, 0x44, 0x78, 0x31, 0x76, 0x6a, 0x01, 0x14,
-	0x85, 0xa8, 0xdb, 0x1a, 0x92, 0xea, 0xad, 0x2f, 0xbc, 0x18, 0xa9, 0x05, 0x90, 0x43, 0xdc, 0xa9,
-	0x25, 0x52, 0xe1, 0x52, 0xda, 0x08, 0x51, 0xb7, 0x3d, 0xdc, 0xaa, 0xf0, 0x8d, 0x70, 0x29, 0x39,
-	0xc2, 0xdb, 0xf0, 0x62, 0x94, 0x5d, 0x8b, 0x60, 0xb4, 0x4c, 0x69, 0x73, 0xf5, 0x6d, 0xa7, 0xe2,
-	0x97, 0x25, 0x26, 0x11, 0xde, 0x98, 0xc1, 0x2c, 0x06, 0xeb, 0x68, 0x2b, 0x6c, 0x76, 0x37, 0x23,
-	0xca, 0xaa, 0x6a, 0x65, 0x13, 0x76, 0x17, 0x3f, 0x82, 0xf4, 0x83, 0xfe, 0xf0, 0x47, 0x3c, 0x7f,
-	0x5e, 0x16, 0x01, 0xfa, 0x28, 0x02, 0xf4, 0x59, 0x04, 0xe8, 0xed, 0x2b, 0xf8, 0xf7, 0x70, 0x91,
-	0x28, 0x9f, 0xce, 0x63, 0x26, 0xf5, 0x8c, 0x67, 0xce, 0x48, 0xd9, 0x9b, 0x40, 0xce, 0x33, 0xd0,
-	0x53, 0xd7, 0x13, 0x46, 0xf5, 0x12, 0xcd, 0xff, 0x9a, 0xf4, 0xb4, 0x4e, 0xde, 0x1b, 0x7b, 0xb7,
-	0xa0, 0xaf, 0x46, 0xec, 0xec, 0x7e, 0x50, 0x1e, 0xaf, 0x8f, 0x15, 0xff, 0x5f, 0x8d, 0x78, 0xf2,
-	0x1d, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x95, 0x67, 0x64, 0x9a, 0x01, 0x00, 0x00,
+	// 306 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x3f, 0x4e, 0xc3, 0x30,
+	0x18, 0xc5, 0x71, 0x5b, 0x81, 0x14, 0x10, 0x45, 0x11, 0x42, 0x86, 0x21, 0x8a, 0x98, 0xca, 0x50,
+	0x1b, 0x85, 0x91, 0xa9, 0xb4, 0xfc, 0xe9, 0x02, 0xa8, 0xdd, 0x58, 0x2a, 0xc7, 0xfd, 0x1a, 0x1b,
+	0x48, 0x6c, 0x6c, 0x37, 0x82, 0x9e, 0x84, 0x33, 0x70, 0x12, 0x46, 0x8e, 0x80, 0xc2, 0x45, 0x50,
+	0x5a, 0xa1, 0x44, 0xa2, 0xeb, 0xf3, 0xef, 0xf9, 0xf7, 0xe9, 0x79, 0x61, 0x1e, 0x51, 0xeb, 0x94,
+	0x61, 0x09, 0x24, 0x46, 0xcd, 0x35, 0x4d, 0x8c, 0xe6, 0xd4, 0xbd, 0x69, 0xb0, 0x44, 0x1b, 0xe5,
+	0x94, 0x7f, 0x90, 0x81, 0x22, 0x33, 0x4b, 0xf2, 0x88, 0xd4, 0xc1, 0x23, 0x9c, 0x47, 0xd4, 0xc0,
+	0xcc, 0xfe, 0x6b, 0x1c, 0x17, 0xc8, 0xdb, 0x19, 0xaf, 0xd0, 0xeb, 0x12, 0xf5, 0x4f, 0xbd, 0xfd,
+	0x9c, 0x3d, 0xcb, 0x29, 0x73, 0x52, 0x65, 0x93, 0x29, 0x73, 0x6c, 0x62, 0xe5, 0x02, 0x30, 0x0a,
+	0x51, 0xa7, 0x35, 0xf2, 0xab, 0xb7, 0x01, 0x73, 0x6c, 0x2c, 0x17, 0xe0, 0xf7, 0xbc, 0x76, 0xad,
+	0x21, 0x98, 0x15, 0xb8, 0x11, 0xa2, 0xce, 0x76, 0x84, 0x49, 0x75, 0x4e, 0x69, 0x27, 0x7d, 0x01,
+	0xfc, 0xc9, 0xce, 0xd3, 0xd1, 0x6e, 0x55, 0xb8, 0x61, 0x56, 0xf8, 0x27, 0xde, 0x1e, 0xbc, 0x6a,
+	0x69, 0x56, 0x5f, 0x80, 0x56, 0x5c, 0xe0, 0xe6, 0x52, 0xd8, 0xae, 0xf2, 0xcb, 0x32, 0xf6, 0x23,
+	0x6f, 0x2b, 0x85, 0x34, 0x06, 0x63, 0x71, 0x2b, 0x6c, 0xae, 0xb3, 0xdc, 0xc5, 0x8f, 0xc0, 0xdd,
+	0x70, 0x30, 0xfa, 0x03, 0x2f, 0x5e, 0x3e, 0x8b, 0x00, 0x7d, 0x15, 0x01, 0xfa, 0x2e, 0x02, 0xf4,
+	0xfe, 0x13, 0x6c, 0x3c, 0xf4, 0x13, 0xe9, 0xc4, 0x3c, 0x26, 0x5c, 0xa5, 0x34, 0xb3, 0x9a, 0xf3,
+	0xee, 0x14, 0x72, 0x9a, 0x81, 0x9a, 0xd9, 0x2e, 0xd3, 0xb2, 0x9b, 0x28, 0xba, 0x6e, 0xec, 0xf3,
+	0x7a, 0xf2, 0xd1, 0x38, 0xbc, 0x05, 0x75, 0x35, 0x26, 0xbd, 0xfb, 0x61, 0x29, 0xaf, 0xcf, 0x18,
+	0x6f, 0x2e, 0xe7, 0x3d, 0xfb, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x31, 0x2e, 0xd2, 0x63, 0xb4, 0x01,
+	0x00, 0x00,
 }
 
 func (m *StorageGroup) Marshal() (dAtA []byte, err error) {
@@ -178,10 +179,15 @@ func (m *StorageGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x18
 	}
-	if len(m.ValidationHash) > 0 {
-		i -= len(m.ValidationHash)
-		copy(dAtA[i:], m.ValidationHash)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidationHash)))
+	if m.ValidationHash != nil {
+		{
+			size, err := m.ValidationHash.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
 		i--
 		dAtA[i] = 0x12
 	}
@@ -213,8 +219,8 @@ func (m *StorageGroup) Size() (n int) {
 	if m.ValidationDataSize != 0 {
 		n += 1 + sovTypes(uint64(m.ValidationDataSize))
 	}
-	l = len(m.ValidationHash)
-	if l > 0 {
+	if m.ValidationHash != nil {
+		l = m.ValidationHash.Size()
 		n += 1 + l + sovTypes(uint64(l))
 	}
 	if m.ExpirationEpoch != 0 {
@@ -290,7 +296,7 @@ func (m *StorageGroup) Unmarshal(dAtA []byte) error {
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ValidationHash", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -300,24 +306,26 @@ func (m *StorageGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthTypes
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ValidationHash = append(m.ValidationHash[:0], dAtA[iNdEx:postIndex]...)
 			if m.ValidationHash == nil {
-				m.ValidationHash = []byte{}
+				m.ValidationHash = &grpc.Checksum{}
+			}
+			if err := m.ValidationHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 3: