[#297] bearer: Update module docstring

Module top level docstring was referencing outdated APIs which do not
exist anymore.

Signed-off-by: Vitaliy Potyarkin <v.potyarkin@yadro.com>

.forgejo/workflows/dco.yml

@@ -1,3 +1,4 @@
+name: DCO
 on: [pull_request]
 
 jobs:
@@ -12,9 +13,9 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.23'
 
       - name: Run commit format checker
-        uses: https://git.alexvan.in/alexvanin/dco-go@v1
+        uses: https://git.frostfs.info/TrueCloudLab/dco-go@v3
         with:
-          from: 406c2324
+          from: 'origin/${{ github.event.pull_request.base.ref }}'

.forgejo/workflows/tests.yml

@@ -1,3 +1,4 @@
+name: Tests and linters
 on: [pull_request]
 
 jobs:
@@ -7,17 +8,24 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: golangci-lint
-        uses: https://github.com/golangci/golangci-lint-action@v2
+      - name: Set up Go
+        uses: actions/setup-go@v3
         with:
-          version: latest
+          go-version: '1.23'
+          cache: true
+
+      - name: Install linters
+        run: make lint-install
+
+      - name: Run linters
+        run: make lint
 
   tests:
     name: Tests
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go_versions: [ '1.19', '1.20' ]
+        go_versions: [ '1.22', '1.23' ]
       fail-fast: false
     steps:
       - uses: actions/checkout@v3

.gitattributes

@@ -2,3 +2,6 @@
 /pkg/policy/parser/generate.go diff
 **/*.interp -diff
 **/*.tokens -diff
+/**/*.pb.go -diff -merge
+/**/*.pb.go linguist-generated=true
+/go.sum -diff

.github/CODEOWNERS

@@ -1 +0,0 @@
-*   @TrueCloudLab/storage-core @TrueCloudLab/storage-services

.gitignore

@@ -23,7 +23,11 @@ coverage.txt
 coverage.html
 
 # antlr tool jar
-antlr-*.jar
+antlr*.jar
 
 # tempfiles
 .cache
+
+# binary
+bin/
+release/

.gitlint

@@ -1,10 +0,0 @@
-[general]
-fail-without-commits=true
-contrib=CC1
-
-[title-match-regex]
-regex=^\[\#[0-9Xx]+\]\s
-
-[ignore-by-title]
-regex=^Release(.*)
-ignore=title-match-regex

.golangci.yml

@@ -12,7 +12,8 @@ run:
 # output configuration options
 output:
   # colored-line-number|line-number|json|tab|checkstyle|code-climate, default is "colored-line-number"
-  format: tab
+  formats:
+    - format: tab
 
 # all available settings of specific linters
 linters-settings:
@@ -25,7 +26,7 @@ linters-settings:
     # report about shadowed variables
     check-shadowing: false
   staticcheck:
-    checks: ["all", "-SA1019"] # TODO Enable SA1019 after deprecated warning are fixed.
+    checks: ["all"]
   funlen:
     lines: 80 # default 60
     statements: 60 # default 40
@@ -51,7 +52,7 @@ linters:
     - bidichk
     - durationcheck
     - exhaustive
-    - exportloopref
+    - copyloopvar
     - gofmt
     - goimports
     - misspell
@@ -62,5 +63,7 @@ linters:
     - funlen
     - gocognit
     - contextcheck
+    - protogetter
+    - intrange
   disable-all: true
   fast: false

.pre-commit-config.yaml

@@ -18,13 +18,19 @@ repos:
     - id: end-of-file-fixer
       exclude: "(.key|.interp|.tokens)$"
 
-  - repo: https://github.com/golangci/golangci-lint
-    rev: v1.51.2
+  - repo: local
     hooks:
-    - id: golangci-lint
+       - id: go-unit-tests
+         name: go unit tests
+         entry: make test GOFLAGS=''
+         pass_filenames: false
+         types: [go]
+         language: system
 
-  - repo: https://github.com/jorisroovers/gitlint
-    rev:  v0.18.0
+  - repo: local
     hooks:
-      - id: gitlint
-        stages: [commit-msg]
+      - id: make-lint
+        name: Run Make Lint
+        entry: make lint
+        language: system
+        pass_filenames: false

CODEOWNERS

@@ -0,0 +1 @@
+.*   @TrueCloudLab/storage-core @TrueCloudLab/storage-services

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.19
+FROM golang:1.22
 
-RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install make openjdk-11-jre -y
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install make openjdk-17-jre -y
 WORKDIR /work

Makefile

@@ -1,10 +1,81 @@
 #!/usr/bin/make -f
 
-ANTLR_VERSION="4.13.0"
+ANTLR_VERSION=4.13.1
+TMP_DIR := .cache
+LINT_VERSION ?= 1.61.0
+TRUECLOUDLAB_LINT_VERSION ?= 0.0.7
+OUTPUT_LINT_DIR ?= $(shell pwd)/bin
+LINT_DIR = $(OUTPUT_LINT_DIR)/golangci-lint-$(LINT_VERSION)-v$(TRUECLOUDLAB_LINT_VERSION)
+
+PROTOC_VERSION ?= 27.2
+PROTOC_GEN_GO_VERSION ?= $(shell go list -f '{{.Version}}' -m google.golang.org/protobuf)
+PROTOC_OS_VERSION=osx-x86_64
+ifeq ($(shell uname), Linux)
+	PROTOC_OS_VERSION=linux-x86_64
+endif
+
+BIN = bin
+PROTOBUF_DIR ?= $(abspath $(BIN))/protobuf
+PROTOC_DIR ?= $(PROTOBUF_DIR)/protoc-v$(PROTOC_VERSION)
+PROTOC_GEN_GO_DIR ?= $(PROTOBUF_DIR)/protoc-gen-go-$(PROTOC_GEN_GO_VERSION)
+
+
+.PHONY: dep imports protoc test lint help $(BIN)/protogen protoc-test
 
 # Run tests
+test: GOFLAGS ?= "-cover -count=1"
 test:
-	@go test ./... -cover
+	@GOFLAGS=$(GOFLAGS) go test ./...
+
+# Reformat imports
+imports:
+	@echo "⇒ Processing goimports check"
+	@for f in `find . -type f -name '*.go' -not -name '*.pb.go' -prune`; do \
+		goimports -w $$f; \
+	done
+
+# Install protoc
+protoc-install:
+	@rm -rf $(PROTOBUF_DIR)
+	@mkdir -p $(PROTOBUF_DIR)
+	@echo "⇒ Installing protoc... "
+	@wget -q -O $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip 'https://github.com/protocolbuffers/protobuf/releases/download/v$(PROTOC_VERSION)/protoc-$(PROTOC_VERSION)-$(PROTOC_OS_VERSION).zip'
+	@unzip -q -o $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip -d $(PROTOC_DIR)
+	@rm $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip
+	@echo "⇒ Installing protoc-gen-go..."
+	@GOBIN=$(PROTOC_GEN_GO_DIR) go install -v google.golang.org/protobuf/...@$(PROTOC_GEN_GO_VERSION)
+
+
+# Regenerate code for proto files
+protoc:
+	@if [ ! -d "$(PROTOC_DIR)" ] || [ ! -d "$(PROTOC_GEN_GO_DIR)" ]; then \
+		make protoc-install; \
+	fi
+	# Protoc generate
+	@for f in `find . -type f -name '*.proto' -not -path './bin/*' -not -path './api/util/proto/test/*'`; do \
+		echo "⇒ Processing $$f "; \
+		$(PROTOC_DIR)/bin/protoc \
+			--proto_path=.:$(PROTOC_DIR)/include:/usr/local/include \
+			--plugin=protoc-gen-go-frostfs=$(abspath ./bin/protogen) \
+			--go-frostfs_out=fuzz=true:. \
+			--go-frostfs_opt=paths=source_relative \
+			--go-grpc_opt=require_unimplemented_servers=false \
+			--go-grpc_out=. --go-grpc_opt=paths=source_relative $$f; \
+	done
+
+$(BIN)/protogen:
+	@go build -v -trimpath \
+		-o $(BIN)/protogen \
+		./api/util/protogen
+
+protoc-test: protoc $(BIN)/protogen
+	@$(PROTOC_DIR)/bin/protoc \
+			--go_out=. --go_opt=paths=source_relative \
+			--plugin=protoc-gen-go-frostfs=$(abspath $(BIN)/protogen) \
+			--go-frostfs_opt=Mapi/util/proto/test/test.proto=git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto/test/custom \
+			--go-frostfs_opt=module=git.frostfs.info/TrueCloudLab/frostfs-sdk-go \
+			--go-frostfs_out=. --go-frostfs_opt=paths=import \
+			./api/util/proto/test/test.proto
 
 # Pull go dependencies
 dep:
@@ -15,9 +86,23 @@ dep:
 	@CGO_ENABLED=0 \
 	go mod tidy -v && echo OK
 
+# Install linters
+lint-install:
+	@mkdir -p $(TMP_DIR)
+	@rm -rf $(TMP_DIR)/linters
+	@git -c advice.detachedHead=false clone --branch v$(TRUECLOUDLAB_LINT_VERSION) https://git.frostfs.info/TrueCloudLab/linters.git $(TMP_DIR)/linters
+	@@make -C $(TMP_DIR)/linters lib CGO_ENABLED=1 OUT_DIR=$(OUTPUT_LINT_DIR)
+	@rm -rf $(TMP_DIR)/linters
+	@rmdir $(TMP_DIR) 2>/dev/null || true
+	@CGO_ENABLED=1 GOBIN=$(LINT_DIR) go install github.com/golangci/golangci-lint/cmd/golangci-lint@v$(LINT_VERSION)
+
 # Run linters
 lint:
-	@golangci-lint --timeout=5m run
+	@if [ ! -d "$(LINT_DIR)" ]; then \
+		echo "Run make lint-install"; \
+		exit 1; \
+	fi
+	$(LINT_DIR)/golangci-lint run
 
 # Run tests with race detection and produce coverage output
 cover:
@@ -33,7 +118,8 @@ format:
 
 policy:
 	@wget -q https://www.antlr.org/download/antlr-${ANTLR_VERSION}-complete.jar -O antlr4-tool.jar
-	@java -Xmx500M -cp "`pwd`/antlr4-tool.jar" "org.antlr.v4.Tool" -o `pwd`/netmap/parser/ -Dlanguage=Go -no-listener -visitor `pwd`/netmap/parser/Query.g4 `pwd`/netmap/parser/QueryLexer.g4
+	@java -Xmx500M -cp antlr4-tool.jar org.antlr.v4.Tool -Dlanguage=Go \
+	-no-listener -visitor netmap/parser/Query.g4 netmap/parser/QueryLexer.g4
 
 # Run `make %` in truecloudlab/frostfs-sdk-go container(Golang+Java)
 docker/%:
@@ -57,3 +143,15 @@ help:
 	@echo '  Targets:'
 	@echo ''
 	@awk '/^#/{ comment = substr($$0,3) } comment && /^[a-zA-Z][a-zA-Z0-9_-]+ ?:/{ print "   ", $$1, comment }' $(MAKEFILE_LIST) | column -t -s ':' | grep -v 'IGNORE' | sort -u
+
+# Activate pre-commit hooks
+pre-commit:
+	pre-commit install --hook-type pre-commit
+
+# Deactivate pre-commit hooks
+unpre-commit:
+	pre-commit uninstall --hook-type pre-commit
+
+# Run pre-commit hooks
+pre-commit-run:
+	@pre-commit run --all-files --hook-stage manual

README.md

@@ -42,7 +42,6 @@ Contains client for working with FrostFS.
 ```go
 var prmInit client.PrmInit
 prmInit.SetDefaultPrivateKey(key) // private key for request signing
-prmInit.ResolveFrostFSFailures() // enable erroneous status parsing
 
 var c client.Client
 c.Init(prmInit)
@@ -77,8 +76,7 @@ if needed and perform any desired action. In the case above we may want to repor
 these details to the user as well as retry an operation, possibly with different parameters.
 Status wire-format is extendable and each node can report any set of details it wants.
 The set of reserved status codes can be found in
-[FrostFS API](https://git.frostfs.info/TrueCloudLab/frostfs-api/src/branch/master/status/types.proto). There is also
-a `client.PrmInit.ResolveFrostFSFailures()` to seamlessly convert erroneous statuses into Go error type.
+[FrostFS API](https://git.frostfs.info/TrueCloudLab/frostfs-api/src/branch/master/status/types.proto).
 
 ### policy
 Contains helpers allowing conversion of placing policy from/to JSON representation

accounting/decimal.go

@@ -1,10 +1,10 @@
 package accounting
 
-import "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/accounting"
+import "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 
 // Decimal represents decimal number for accounting operations.
 //
-// Decimal is mutually compatible with git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/accounting.Decimal
+// Decimal is mutually compatible with git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting.Decimal
 // message. See ReadFromV2 / WriteToV2 methods.
 //
 // Instances can be created using built-in var declaration.

accounting/decimal_test.go

@@ -3,8 +3,8 @@ package accounting_test
 import (
 	"testing"
 
-	v2accounting "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/accounting"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting"
+	v2accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 	"github.com/stretchr/testify/require"
 )
 

accounting/doc.go

@@ -13,7 +13,7 @@ Instances can be also used to process FrostFS API V2 protocol messages
 
 On client side:
 
-	import "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/accounting"
+	import "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 
 	var msg accounting.Decimal
 	dec.WriteToV2(&msg)

ape/chain.go

@@ -0,0 +1,52 @@
+package ape
+
+import (
+	"errors"
+	"fmt"
+
+	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+)
+
+var (
+	ErrInvalidChainRepresentation = errors.New("invalid chain representation")
+)
+
+// ChainID is Chain's identifier.
+type ChainID []byte
+
+// Chain is an SDK representation for v2's Chain.
+//
+// Note that Chain (as well as v2's Chain) and all related entities
+// are NOT operated by Access-Policy-Engine (APE). The client is responsible
+// to convert these types to policy-engine entities.
+type Chain struct {
+	// Raw is the encoded chain kind.
+	// It assumes that Raw's bytes are the result of encoding provided by
+	// policy-engine package.
+	Raw []byte
+}
+
+// ToV2 converts Chain to v2.
+func (c *Chain) ToV2() *apeV2.Chain {
+	v2ct := new(apeV2.Chain)
+
+	if c.Raw != nil {
+		v2Raw := new(apeV2.ChainRaw)
+		v2Raw.SetRaw(c.Raw)
+		v2ct.SetKind(v2Raw)
+	}
+
+	return v2ct
+}
+
+// ReadFromV2 fills Chain from v2.
+func (c *Chain) ReadFromV2(v2ct *apeV2.Chain) error {
+	switch v := v2ct.GetKind().(type) {
+	default:
+		return fmt.Errorf("unsupported chain kind: %T", v)
+	case *apeV2.ChainRaw:
+		raw := v.GetRaw()
+		c.Raw = raw
+	}
+	return nil
+}

ape/chain_target.go

@@ -0,0 +1,53 @@
+package ape
+
+import (
+	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+)
+
+// TargetType is an SDK representation for v2's TargetType.
+type TargetType apeV2.TargetType
+
+const (
+	TargetTypeUndefined TargetType = iota
+	TargetTypeNamespace
+	TargetTypeContainer
+	TargetTypeUser
+	TargetTypeGroup
+)
+
+// ToV2 converts TargetType to v2.
+func (targetType TargetType) ToV2() apeV2.TargetType {
+	return apeV2.TargetType(targetType)
+}
+
+// FromV2 reads TargetType to v2.
+func (targetType *TargetType) FromV2(v2targetType apeV2.TargetType) {
+	*targetType = TargetType(v2targetType)
+}
+
+// ChainTarget is an SDK representation for v2's ChainTarget.
+//
+// Note that ChainTarget (as well as v2's ChainTarget) and all related entities
+// are NOT operated by Access-Policy-Engine (APE). The client is responsible
+// to convert these types to policy-engine entities.
+type ChainTarget struct {
+	TargetType TargetType
+
+	Name string
+}
+
+// ToV2 converts ChainTarget to v2.
+func (ct *ChainTarget) ToV2() *apeV2.ChainTarget {
+	v2ct := new(apeV2.ChainTarget)
+
+	v2ct.SetTargetType(ct.TargetType.ToV2())
+	v2ct.SetName(ct.Name)
+
+	return v2ct
+}
+
+// FromV2 reads ChainTarget frpm v2.
+func (ct *ChainTarget) FromV2(v2ct *apeV2.ChainTarget) {
+	ct.TargetType.FromV2(v2ct.GetTargetType())
+	ct.Name = v2ct.GetName()
+}

ape/chain_target_test.go

@@ -0,0 +1,65 @@
+package ape_test
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/ape"
+	"github.com/stretchr/testify/require"
+
+	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+)
+
+var (
+	m = map[ape.TargetType]apeV2.TargetType{
+		ape.TargetTypeUndefined: apeV2.TargetTypeUndefined,
+		ape.TargetTypeNamespace: apeV2.TargetTypeNamespace,
+		ape.TargetTypeContainer: apeV2.TargetTypeContainer,
+		ape.TargetTypeUser:      apeV2.TargetTypeUser,
+		ape.TargetTypeGroup:     apeV2.TargetTypeGroup,
+	}
+)
+
+func TestTargetType(t *testing.T) {
+	for typesdk, typev2 := range m {
+		t.Run("from sdk to v2 "+typev2.String(), func(t *testing.T) {
+			v2 := typesdk.ToV2()
+			require.Equal(t, v2, typev2)
+		})
+
+		t.Run("from v2 to sdk "+typev2.String(), func(t *testing.T) {
+			var typ ape.TargetType
+			typ.FromV2(typev2)
+			require.Equal(t, typesdk, typ)
+		})
+	}
+}
+
+func TestChainTarget(t *testing.T) {
+	var (
+		typ  = ape.TargetTypeNamespace
+		name = "namespaceXXYYZZ"
+	)
+
+	t.Run("from sdk to v2", func(t *testing.T) {
+		ct := ape.ChainTarget{
+			TargetType: typ,
+			Name:       name,
+		}
+
+		v2 := ct.ToV2()
+		require.Equal(t, m[typ], v2.GetTargetType())
+		require.Equal(t, name, v2.GetName())
+	})
+
+	t.Run("from v2 to sdk", func(t *testing.T) {
+		v2 := &apeV2.ChainTarget{}
+		v2.SetTargetType(m[typ])
+		v2.SetName(name)
+
+		var ct ape.ChainTarget
+		ct.FromV2(v2)
+
+		require.Equal(t, typ, ct.TargetType)
+		require.Equal(t, name, ct.Name)
+	})
+}

ape/chain_test.go

@@ -0,0 +1,43 @@
+package ape_test
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/ape"
+	"github.com/stretchr/testify/require"
+
+	apeV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+)
+
+const (
+	encoded = `{"ID":"","Rules":[{"Status":"Allow","Actions":{"Inverted":false,"Names":["GetObject"]},"Resources":{"Inverted":false,"Names":["native:object/*"]},"Any":false,"Condition":[{"Op":"StringEquals","Object":"Resource","Key":"Department","Value":"HR"}]}],"MatchType":"DenyPriority"}`
+)
+
+func TestChainData(t *testing.T) {
+	t.Run("raw chain", func(t *testing.T) {
+		var c ape.Chain
+
+		b := []byte(encoded)
+		c.Raw = b
+
+		v2, ok := c.ToV2().GetKind().(*apeV2.ChainRaw)
+		require.True(t, ok)
+		require.Equal(t, b, v2.Raw)
+	})
+}
+
+func TestChainMessageV2(t *testing.T) {
+	b := []byte(encoded)
+
+	v2Raw := &apeV2.ChainRaw{}
+	v2Raw.SetRaw(b)
+
+	v2 := &apeV2.Chain{}
+	v2.SetKind(v2Raw)
+
+	var c ape.Chain
+	c.ReadFromV2(v2)
+
+	require.NotNil(t, c.Raw)
+	require.Equal(t, b, c.Raw)
+}

ape/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,45 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package ape
+
+func DoFuzzProtoChainTarget(data []byte) int {
+	msg := new(ChainTarget)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONChainTarget(data []byte) int {
+	msg := new(ChainTarget)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoChain(data []byte) int {
+	msg := new(Chain)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONChain(data []byte) int {
+	msg := new(Chain)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

ape/grpc/types_frostfs_test.go

@@ -0,0 +1,31 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package ape
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoChainTarget(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoChainTarget(data)
+	})
+}
+func FuzzJSONChainTarget(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONChainTarget(data)
+	})
+}
+func FuzzProtoChain(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoChain(data)
+	})
+}
+func FuzzJSONChain(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONChain(data)
+	})
+}

api/accounting/accounting.go

@@ -0,0 +1,104 @@
+package accounting
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
+)
+
+type BalanceRequestBody struct {
+	ownerID *refs.OwnerID
+}
+
+type BalanceResponseBody struct {
+	bal *Decimal
+}
+
+type Decimal struct {
+	val int64
+
+	prec uint32
+}
+
+type BalanceRequest struct {
+	body *BalanceRequestBody
+
+	session.RequestHeaders
+}
+
+type BalanceResponse struct {
+	body *BalanceResponseBody
+
+	session.ResponseHeaders
+}
+
+func (b *BalanceRequestBody) GetOwnerID() *refs.OwnerID {
+	if b != nil {
+		return b.ownerID
+	}
+
+	return nil
+}
+
+func (b *BalanceRequestBody) SetOwnerID(v *refs.OwnerID) {
+	b.ownerID = v
+}
+
+func (b *BalanceRequest) GetBody() *BalanceRequestBody {
+	if b != nil {
+		return b.body
+	}
+
+	return nil
+}
+
+func (b *BalanceRequest) SetBody(v *BalanceRequestBody) {
+	b.body = v
+}
+
+func (d *Decimal) GetValue() int64 {
+	if d != nil {
+		return d.val
+	}
+
+	return 0
+}
+
+func (d *Decimal) SetValue(v int64) {
+	d.val = v
+}
+
+func (d *Decimal) GetPrecision() uint32 {
+	if d != nil {
+		return d.prec
+	}
+
+	return 0
+}
+
+func (d *Decimal) SetPrecision(v uint32) {
+	d.prec = v
+}
+
+func (br *BalanceResponseBody) GetBalance() *Decimal {
+	if br != nil {
+		return br.bal
+	}
+
+	return nil
+}
+
+func (br *BalanceResponseBody) SetBalance(v *Decimal) {
+	br.bal = v
+}
+
+func (br *BalanceResponse) GetBody() *BalanceResponseBody {
+	if br != nil {
+		return br.body
+	}
+
+	return nil
+}
+
+func (br *BalanceResponse) SetBody(v *BalanceResponseBody) {
+	br.body = v
+}

api/accounting/convert.go

@@ -0,0 +1,178 @@
+package accounting
+
+import (
+	accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
+	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (b *BalanceRequestBody) ToGRPCMessage() grpc.Message {
+	var m *accounting.BalanceRequest_Body
+
+	if b != nil {
+		m = new(accounting.BalanceRequest_Body)
+
+		m.SetOwnerId(b.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
+	}
+
+	return m
+}
+
+func (b *BalanceRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*accounting.BalanceRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	ownerID := v.GetOwnerId()
+	if ownerID == nil {
+		b.ownerID = nil
+	} else {
+		if b.ownerID == nil {
+			b.ownerID = new(refs.OwnerID)
+		}
+
+		err = b.ownerID.FromGRPCMessage(ownerID)
+	}
+
+	return err
+}
+
+func (b *BalanceRequest) ToGRPCMessage() grpc.Message {
+	var m *accounting.BalanceRequest
+
+	if b != nil {
+		m = new(accounting.BalanceRequest)
+
+		m.SetBody(b.body.ToGRPCMessage().(*accounting.BalanceRequest_Body))
+		b.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (b *BalanceRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*accounting.BalanceRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		b.body = nil
+	} else {
+		if b.body == nil {
+			b.body = new(BalanceRequestBody)
+		}
+
+		err = b.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return b.RequestHeaders.FromMessage(v)
+}
+
+func (d *Decimal) ToGRPCMessage() grpc.Message {
+	var m *accounting.Decimal
+
+	if d != nil {
+		m = new(accounting.Decimal)
+
+		m.SetValue(d.val)
+		m.SetPrecision(d.prec)
+	}
+
+	return m
+}
+
+func (d *Decimal) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*accounting.Decimal)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	d.val = v.GetValue()
+	d.prec = v.GetPrecision()
+
+	return nil
+}
+
+func (br *BalanceResponseBody) ToGRPCMessage() grpc.Message {
+	var m *accounting.BalanceResponse_Body
+
+	if br != nil {
+		m = new(accounting.BalanceResponse_Body)
+
+		m.SetBalance(br.bal.ToGRPCMessage().(*accounting.Decimal))
+	}
+
+	return m
+}
+
+func (br *BalanceResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*accounting.BalanceResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	bal := v.GetBalance()
+	if bal == nil {
+		br.bal = nil
+	} else {
+		if br.bal == nil {
+			br.bal = new(Decimal)
+		}
+
+		err = br.bal.FromGRPCMessage(bal)
+	}
+
+	return err
+}
+
+func (br *BalanceResponse) ToGRPCMessage() grpc.Message {
+	var m *accounting.BalanceResponse
+
+	if br != nil {
+		m = new(accounting.BalanceResponse)
+
+		m.SetBody(br.body.ToGRPCMessage().(*accounting.BalanceResponse_Body))
+		br.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (br *BalanceResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*accounting.BalanceResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		br.body = nil
+	} else {
+		if br.body == nil {
+			br.body = new(BalanceResponseBody)
+		}
+
+		err = br.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return br.ResponseHeaders.FromMessage(v)
+}

api/accounting/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,45 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+func DoFuzzProtoBalanceRequest(data []byte) int {
+	msg := new(BalanceRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONBalanceRequest(data []byte) int {
+	msg := new(BalanceRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoBalanceResponse(data []byte) int {
+	msg := new(BalanceResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONBalanceResponse(data []byte) int {
+	msg := new(BalanceResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/accounting/grpc/service_frostfs_test.go

@@ -0,0 +1,31 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoBalanceRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoBalanceRequest(data)
+	})
+}
+func FuzzJSONBalanceRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONBalanceRequest(data)
+	})
+}
+func FuzzProtoBalanceResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoBalanceResponse(data)
+	})
+}
+func FuzzJSONBalanceResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONBalanceResponse(data)
+	})
+}

api/accounting/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,26 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+func DoFuzzProtoDecimal(data []byte) int {
+	msg := new(Decimal)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONDecimal(data []byte) int {
+	msg := new(Decimal)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/accounting/grpc/types_frostfs_test.go

@@ -0,0 +1,21 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoDecimal(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoDecimal(data)
+	})
+}
+func FuzzJSONDecimal(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONDecimal(data)
+	})
+}

api/accounting/json.go

@@ -0,0 +1,14 @@
+package accounting
+
+import (
+	accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (d *Decimal) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(d)
+}
+
+func (d *Decimal) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(d, data, new(accounting.Decimal))
+}

api/accounting/marshal.go

@@ -0,0 +1,104 @@
+package accounting
+
+import (
+	accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	protoutil "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
+)
+
+const (
+	decimalValueField     = 1
+	decimalPrecisionField = 2
+
+	balanceReqBodyOwnerField = 1
+
+	balanceRespBodyDecimalField = 1
+)
+
+func (d *Decimal) StableMarshal(buf []byte) []byte {
+	if d == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, d.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.Int64Marshal(decimalValueField, buf[offset:], d.val)
+	protoutil.UInt32Marshal(decimalPrecisionField, buf[offset:], d.prec)
+
+	return buf
+}
+
+func (d *Decimal) StableSize() (size int) {
+	if d == nil {
+		return 0
+	}
+
+	size += protoutil.Int64Size(decimalValueField, d.val)
+	size += protoutil.UInt32Size(decimalPrecisionField, d.prec)
+
+	return size
+}
+
+func (d *Decimal) Unmarshal(data []byte) error {
+	return message.Unmarshal(d, data, new(accounting.Decimal))
+}
+
+func (b *BalanceRequestBody) StableMarshal(buf []byte) []byte {
+	if b == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, b.StableSize())
+	}
+
+	protoutil.NestedStructureMarshal(balanceReqBodyOwnerField, buf, b.ownerID)
+
+	return buf
+}
+
+func (b *BalanceRequestBody) StableSize() (size int) {
+	if b == nil {
+		return 0
+	}
+
+	size = protoutil.NestedStructureSize(balanceReqBodyOwnerField, b.ownerID)
+
+	return size
+}
+
+func (b *BalanceRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(b, data, new(accounting.BalanceRequest_Body))
+}
+
+func (br *BalanceResponseBody) StableMarshal(buf []byte) []byte {
+	if br == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, br.StableSize())
+	}
+
+	protoutil.NestedStructureMarshal(balanceRespBodyDecimalField, buf, br.bal)
+
+	return buf
+}
+
+func (br *BalanceResponseBody) StableSize() (size int) {
+	if br == nil {
+		return 0
+	}
+
+	size = protoutil.NestedStructureSize(balanceRespBodyDecimalField, br.bal)
+
+	return size
+}
+
+func (br *BalanceResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(br, data, new(accounting.BalanceResponse_Body))
+}

api/accounting/message_test.go

@@ -0,0 +1,19 @@
+package accounting_test
+
+import (
+	"testing"
+
+	accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
+)
+
+func TestMessage(t *testing.T) {
+	messagetest.TestRPCMessage(t,
+		func(empty bool) message.Message { return accountingtest.GenerateDecimal(empty) },
+		func(empty bool) message.Message { return accountingtest.GenerateBalanceRequestBody(empty) },
+		func(empty bool) message.Message { return accountingtest.GenerateBalanceRequest(empty) },
+		func(empty bool) message.Message { return accountingtest.GenerateBalanceResponseBody(empty) },
+		func(empty bool) message.Message { return accountingtest.GenerateBalanceResponse(empty) },
+	)
+}

api/accounting/test/generate.go

@@ -0,0 +1,64 @@
+package accountingtest
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
+	accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/test"
+	sessiontest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/test"
+)
+
+func GenerateBalanceRequest(empty bool) *accounting.BalanceRequest {
+	m := new(accounting.BalanceRequest)
+
+	if !empty {
+		m.SetBody(GenerateBalanceRequestBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateBalanceRequestBody(empty bool) *accounting.BalanceRequestBody {
+	m := new(accounting.BalanceRequestBody)
+
+	if !empty {
+		m.SetOwnerID(accountingtest.GenerateOwnerID(false))
+	}
+
+	return m
+}
+
+func GenerateBalanceResponse(empty bool) *accounting.BalanceResponse {
+	m := new(accounting.BalanceResponse)
+
+	if !empty {
+		m.SetBody(GenerateBalanceResponseBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateBalanceResponseBody(empty bool) *accounting.BalanceResponseBody {
+	m := new(accounting.BalanceResponseBody)
+
+	if !empty {
+		m.SetBalance(GenerateDecimal(false))
+	}
+
+	return m
+}
+
+func GenerateDecimal(empty bool) *accounting.Decimal {
+	m := new(accounting.Decimal)
+
+	if !empty {
+		m.SetValue(1)
+		m.SetPrecision(2)
+	}
+
+	return m
+}

api/acl/bench_test.go

@@ -0,0 +1,51 @@
+package acl_test
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl"
+	aclGrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
+	acltest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/test"
+)
+
+func BenchmarkTable_ToGRPCMessage(b *testing.B) {
+	const size = 4
+
+	tb := new(acl.Table)
+	rs := make([]acl.Record, size)
+	for i := range rs {
+		fs := make([]acl.HeaderFilter, size)
+		for j := range fs {
+			fs[j] = *acltest.GenerateFilter(false)
+		}
+		ts := make([]acl.Target, size)
+		for j := range ts {
+			ts[j] = *acltest.GenerateTarget(false)
+		}
+
+		rs[i].SetFilters(fs)
+		rs[i].SetTargets(ts)
+	}
+	tb.SetRecords(rs)
+
+	raw := tb.ToGRPCMessage()
+
+	b.Run("to grpc message", func(b *testing.B) {
+		b.ReportAllocs()
+		for range b.N {
+			raw := tb.ToGRPCMessage()
+			if len(tb.GetRecords()) != len(raw.(*aclGrpc.EACLTable).Records) {
+				b.FailNow()
+			}
+		}
+	})
+	b.Run("from grpc message", func(b *testing.B) {
+		b.ReportAllocs()
+		for range b.N {
+			tb := new(acl.Table)
+			if tb.FromGRPCMessage(raw) != nil {
+				b.FailNow()
+			}
+		}
+	})
+}

api/acl/convert.go

@@ -0,0 +1,592 @@
+package acl
+
+import (
+	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+	apeGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
+	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+// RoleToGRPCField converts unified role enum into grpc enum.
+func RoleToGRPCField(t Role) acl.Role {
+	switch t {
+	case RoleUser:
+		return acl.Role_USER
+	case RoleSystem:
+		return acl.Role_SYSTEM
+	case RoleOthers:
+		return acl.Role_OTHERS
+	default:
+		return acl.Role_ROLE_UNSPECIFIED
+	}
+}
+
+// RoleFromGRPCField converts grpc enum into unified role enum.
+func RoleFromGRPCField(t acl.Role) Role {
+	switch t {
+	case acl.Role_USER:
+		return RoleUser
+	case acl.Role_SYSTEM:
+		return RoleSystem
+	case acl.Role_OTHERS:
+		return RoleOthers
+	default:
+		return RoleUnknown
+	}
+}
+
+// OperationToGRPCField converts unified operation enum into grpc enum.
+func OperationToGRPCField(t Operation) acl.Operation {
+	switch t {
+	case OperationPut:
+		return acl.Operation_PUT
+	case OperationDelete:
+		return acl.Operation_DELETE
+	case OperationGet:
+		return acl.Operation_GET
+	case OperationHead:
+		return acl.Operation_HEAD
+	case OperationSearch:
+		return acl.Operation_SEARCH
+	case OperationRange:
+		return acl.Operation_GETRANGE
+	case OperationRangeHash:
+		return acl.Operation_GETRANGEHASH
+	default:
+		return acl.Operation_OPERATION_UNSPECIFIED
+	}
+}
+
+// OperationFromGRPCField converts grpc enum into unified operation enum.
+func OperationFromGRPCField(t acl.Operation) Operation {
+	switch t {
+	case acl.Operation_PUT:
+		return OperationPut
+	case acl.Operation_DELETE:
+		return OperationDelete
+	case acl.Operation_GET:
+		return OperationGet
+	case acl.Operation_HEAD:
+		return OperationHead
+	case acl.Operation_SEARCH:
+		return OperationSearch
+	case acl.Operation_GETRANGE:
+		return OperationRange
+	case acl.Operation_GETRANGEHASH:
+		return OperationRangeHash
+	default:
+		return OperationUnknown
+	}
+}
+
+// ActionToGRPCField converts unified action enum into grpc enum.
+func ActionToGRPCField(t Action) acl.Action {
+	switch t {
+	case ActionDeny:
+		return acl.Action_DENY
+	case ActionAllow:
+		return acl.Action_ALLOW
+	default:
+		return acl.Action_ACTION_UNSPECIFIED
+	}
+}
+
+// ActionFromGRPCField converts grpc enum into unified action enum.
+func ActionFromGRPCField(t acl.Action) Action {
+	switch t {
+	case acl.Action_DENY:
+		return ActionDeny
+	case acl.Action_ALLOW:
+		return ActionAllow
+	default:
+		return ActionUnknown
+	}
+}
+
+// HeaderTypeToGRPCField converts unified header type enum into grpc enum.
+func HeaderTypeToGRPCField(t HeaderType) acl.HeaderType {
+	switch t {
+	case HeaderTypeRequest:
+		return acl.HeaderType_REQUEST
+	case HeaderTypeObject:
+		return acl.HeaderType_OBJECT
+	case HeaderTypeService:
+		return acl.HeaderType_SERVICE
+	default:
+		return acl.HeaderType_HEADER_UNSPECIFIED
+	}
+}
+
+// HeaderTypeFromGRPCField converts grpc enum into unified header type enum.
+func HeaderTypeFromGRPCField(t acl.HeaderType) HeaderType {
+	switch t {
+	case acl.HeaderType_REQUEST:
+		return HeaderTypeRequest
+	case acl.HeaderType_OBJECT:
+		return HeaderTypeObject
+	case acl.HeaderType_SERVICE:
+		return HeaderTypeService
+	default:
+		return HeaderTypeUnknown
+	}
+}
+
+// MatchTypeToGRPCField converts unified match type enum into grpc enum.
+func MatchTypeToGRPCField(t MatchType) acl.MatchType {
+	switch t {
+	case MatchTypeStringEqual:
+		return acl.MatchType_STRING_EQUAL
+	case MatchTypeStringNotEqual:
+		return acl.MatchType_STRING_NOT_EQUAL
+	default:
+		return acl.MatchType_MATCH_TYPE_UNSPECIFIED
+	}
+}
+
+// MatchTypeFromGRPCField converts grpc enum into unified match type enum.
+func MatchTypeFromGRPCField(t acl.MatchType) MatchType {
+	switch t {
+	case acl.MatchType_STRING_EQUAL:
+		return MatchTypeStringEqual
+	case acl.MatchType_STRING_NOT_EQUAL:
+		return MatchTypeStringNotEqual
+	default:
+		return MatchTypeUnknown
+	}
+}
+
+func (f *HeaderFilter) ToGRPCMessage() grpc.Message {
+	var m *acl.EACLRecord_Filter
+
+	if f != nil {
+		m = new(acl.EACLRecord_Filter)
+
+		m.SetKey(f.key)
+		m.SetValue(f.value)
+		m.SetHeaderType(HeaderTypeToGRPCField(f.hdrType))
+		m.SetMatchType(MatchTypeToGRPCField(f.matchType))
+	}
+
+	return m
+}
+
+func (f *HeaderFilter) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.EACLRecord_Filter)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	f.key = v.GetKey()
+	f.value = v.GetValue()
+	f.hdrType = HeaderTypeFromGRPCField(v.GetHeaderType())
+	f.matchType = MatchTypeFromGRPCField(v.GetMatchType())
+
+	return nil
+}
+
+func HeaderFiltersToGRPC(fs []HeaderFilter) (res []acl.EACLRecord_Filter) {
+	if fs != nil {
+		res = make([]acl.EACLRecord_Filter, 0, len(fs))
+
+		for i := range fs {
+			res = append(res, *fs[i].ToGRPCMessage().(*acl.EACLRecord_Filter))
+		}
+	}
+
+	return
+}
+
+func HeaderFiltersFromGRPC(fs []acl.EACLRecord_Filter) (res []HeaderFilter, err error) {
+	if fs != nil {
+		res = make([]HeaderFilter, len(fs))
+
+		for i := range fs {
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (t *Target) ToGRPCMessage() grpc.Message {
+	var m *acl.EACLRecord_Target
+
+	if t != nil {
+		m = new(acl.EACLRecord_Target)
+
+		m.SetRole(RoleToGRPCField(t.role))
+		m.SetKeys(t.keys)
+	}
+
+	return m
+}
+
+func (t *Target) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.EACLRecord_Target)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	t.role = RoleFromGRPCField(v.GetRole())
+	t.keys = v.GetKeys()
+
+	return nil
+}
+
+func TargetsToGRPC(ts []Target) (res []acl.EACLRecord_Target) {
+	if ts != nil {
+		res = make([]acl.EACLRecord_Target, 0, len(ts))
+
+		for i := range ts {
+			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord_Target))
+		}
+	}
+
+	return
+}
+
+func TargetsFromGRPC(fs []acl.EACLRecord_Target) (res []Target, err error) {
+	if fs != nil {
+		res = make([]Target, len(fs))
+
+		for i := range fs {
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (r *Record) ToGRPCMessage() grpc.Message {
+	var m *acl.EACLRecord
+
+	if r != nil {
+		m = new(acl.EACLRecord)
+
+		m.SetOperation(OperationToGRPCField(r.op))
+		m.SetAction(ActionToGRPCField(r.action))
+		m.SetFilters(HeaderFiltersToGRPC(r.filters))
+		m.SetTargets(TargetsToGRPC(r.targets))
+	}
+
+	return m
+}
+
+func (r *Record) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.EACLRecord)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	r.filters, err = HeaderFiltersFromGRPC(v.GetFilters())
+	if err != nil {
+		return err
+	}
+
+	r.targets, err = TargetsFromGRPC(v.GetTargets())
+	if err != nil {
+		return err
+	}
+
+	r.op = OperationFromGRPCField(v.GetOperation())
+	r.action = ActionFromGRPCField(v.GetAction())
+
+	return nil
+}
+
+func RecordsToGRPC(ts []Record) (res []acl.EACLRecord) {
+	if ts != nil {
+		res = make([]acl.EACLRecord, 0, len(ts))
+
+		for i := range ts {
+			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord))
+		}
+	}
+
+	return
+}
+
+func RecordsFromGRPC(fs []acl.EACLRecord) (res []Record, err error) {
+	if fs != nil {
+		res = make([]Record, len(fs))
+
+		for i := range fs {
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (t *Table) ToGRPCMessage() grpc.Message {
+	var m *acl.EACLTable
+
+	if t != nil {
+		m = new(acl.EACLTable)
+
+		m.SetVersion(t.version.ToGRPCMessage().(*refsGRPC.Version))
+		m.SetContainerId(t.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
+		m.SetRecords(RecordsToGRPC(t.records))
+	}
+
+	return m
+}
+
+func (t *Table) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.EACLTable)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	cid := v.GetContainerId()
+	if cid == nil {
+		t.cid = nil
+	} else {
+		if t.cid == nil {
+			t.cid = new(refs.ContainerID)
+		}
+
+		err = t.cid.FromGRPCMessage(cid)
+		if err != nil {
+			return err
+		}
+	}
+
+	version := v.GetVersion()
+	if version == nil {
+		t.version = nil
+	} else {
+		if t.version == nil {
+			t.version = new(refs.Version)
+		}
+
+		err = t.version.FromGRPCMessage(version)
+		if err != nil {
+			return err
+		}
+	}
+
+	t.records, err = RecordsFromGRPC(v.GetRecords())
+
+	return err
+}
+
+func (l *TokenLifetime) ToGRPCMessage() grpc.Message {
+	var m *acl.BearerToken_Body_TokenLifetime
+
+	if l != nil {
+		m = new(acl.BearerToken_Body_TokenLifetime)
+
+		m.SetExp(l.exp)
+		m.SetIat(l.iat)
+		m.SetNbf(l.nbf)
+	}
+
+	return m
+}
+
+func (l *TokenLifetime) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.BearerToken_Body_TokenLifetime)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	l.exp = v.GetExp()
+	l.iat = v.GetIat()
+	l.nbf = v.GetNbf()
+
+	return nil
+}
+
+func (c *APEOverride) ToGRPCMessage() grpc.Message {
+	var m *acl.BearerToken_Body_APEOverride
+
+	if c != nil {
+		m = new(acl.BearerToken_Body_APEOverride)
+
+		m.SetTarget(c.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
+
+		if len(c.chains) > 0 {
+			apeChains := make([]apeGRPC.Chain, len(c.chains))
+			for i := range c.chains {
+				apeChains[i] = *c.chains[i].ToGRPCMessage().(*apeGRPC.Chain)
+			}
+			m.SetChains(apeChains)
+		}
+	}
+
+	return m
+}
+
+func (c *APEOverride) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.BearerToken_Body_APEOverride)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	if targetGRPC := v.GetTarget(); targetGRPC != nil {
+		if c.target == nil {
+			c.target = new(ape.ChainTarget)
+		}
+		if err := c.target.FromGRPCMessage(v.GetTarget()); err != nil {
+			return err
+		}
+	}
+
+	if apeChains := v.GetChains(); len(apeChains) > 0 {
+		c.chains = make([]*ape.Chain, len(apeChains))
+		for i := range apeChains {
+			c.chains[i] = new(ape.Chain)
+			if err := c.chains[i].FromGRPCMessage(&apeChains[i]); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (bt *BearerTokenBody) ToGRPCMessage() grpc.Message {
+	var m *acl.BearerToken_Body
+
+	if bt != nil {
+		m = new(acl.BearerToken_Body)
+
+		m.SetOwnerId(bt.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
+		m.SetLifetime(bt.lifetime.ToGRPCMessage().(*acl.BearerToken_Body_TokenLifetime))
+		m.SetEaclTable(bt.eacl.ToGRPCMessage().(*acl.EACLTable))
+		m.SetAllowImpersonate(bt.impersonate)
+		m.SetApeOverride(bt.apeOverride.ToGRPCMessage().(*acl.BearerToken_Body_APEOverride))
+	}
+
+	return m
+}
+
+func (bt *BearerTokenBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.BearerToken_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	ownerID := v.GetOwnerId()
+	if ownerID == nil {
+		bt.ownerID = nil
+	} else {
+		if bt.ownerID == nil {
+			bt.ownerID = new(refs.OwnerID)
+		}
+
+		err = bt.ownerID.FromGRPCMessage(ownerID)
+		if err != nil {
+			return err
+		}
+	}
+
+	lifetime := v.GetLifetime()
+	if lifetime == nil {
+		bt.lifetime = nil
+	} else {
+		if bt.lifetime == nil {
+			bt.lifetime = new(TokenLifetime)
+		}
+
+		err = bt.lifetime.FromGRPCMessage(lifetime)
+		if err != nil {
+			return err
+		}
+	}
+
+	eacl := v.GetEaclTable()
+	if eacl == nil {
+		bt.eacl = nil
+	} else {
+		if bt.eacl == nil {
+			bt.eacl = new(Table)
+		}
+
+		if err = bt.eacl.FromGRPCMessage(eacl); err != nil {
+			return err
+		}
+	}
+
+	if apeOverrideGRPC := v.GetApeOverride(); apeOverrideGRPC != nil {
+		if bt.apeOverride == nil {
+			bt.apeOverride = new(APEOverride)
+		}
+		err = bt.apeOverride.FromGRPCMessage(apeOverrideGRPC)
+		if err != nil {
+			return err
+		}
+	}
+
+	bt.impersonate = v.GetAllowImpersonate()
+
+	return err
+}
+
+func (bt *BearerToken) ToGRPCMessage() grpc.Message {
+	var m *acl.BearerToken
+
+	if bt != nil {
+		m = new(acl.BearerToken)
+
+		m.SetBody(bt.body.ToGRPCMessage().(*acl.BearerToken_Body))
+		m.SetSignature(bt.sig.ToGRPCMessage().(*refsGRPC.Signature))
+	}
+
+	return m
+}
+
+func (bt *BearerToken) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.BearerToken)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		bt.body = nil
+	} else {
+		if bt.body == nil {
+			bt.body = new(BearerTokenBody)
+		}
+
+		err = bt.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	sig := v.GetSignature()
+	if sig == nil {
+		bt.sig = nil
+	} else {
+		if bt.sig == nil {
+			bt.sig = new(refs.Signature)
+		}
+
+		err = bt.sig.FromGRPCMessage(sig)
+	}
+
+	return err
+}

api/acl/filters.go

@@ -0,0 +1,33 @@
+package acl
+
+// ObjectFilterPrefix is a prefix of key to object header value or property.
+const ObjectFilterPrefix = "$Object:"
+
+const (
+	// FilterObjectVersion is a filter key to "version" field of the object header.
+	FilterObjectVersion = ObjectFilterPrefix + "version"
+
+	// FilterObjectID is a filter key to "object_id" field of the object.
+	FilterObjectID = ObjectFilterPrefix + "objectID"
+
+	// FilterObjectContainerID is a filter key to "container_id" field of the object header.
+	FilterObjectContainerID = ObjectFilterPrefix + "containerID"
+
+	// FilterObjectOwnerID is a filter key to "owner_id" field of the object header.
+	FilterObjectOwnerID = ObjectFilterPrefix + "ownerID"
+
+	// FilterObjectCreationEpoch is a filter key to "creation_epoch" field of the object header.
+	FilterObjectCreationEpoch = ObjectFilterPrefix + "creationEpoch"
+
+	// FilterObjectPayloadLength is a filter key to "payload_length" field of the object header.
+	FilterObjectPayloadLength = ObjectFilterPrefix + "payloadLength"
+
+	// FilterObjectPayloadHash is a filter key to "payload_hash" field of the object header.
+	FilterObjectPayloadHash = ObjectFilterPrefix + "payloadHash"
+
+	// FilterObjectType is a filter key to "object_type" field of the object header.
+	FilterObjectType = ObjectFilterPrefix + "objectType"
+
+	// FilterObjectHomomorphicHash is a filter key to "homomorphic_hash" field of the object header.
+	FilterObjectHomomorphicHash = ObjectFilterPrefix + "homomorphicHash"
+)

api/acl/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,64 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package acl
+
+func DoFuzzProtoEACLRecord(data []byte) int {
+	msg := new(EACLRecord)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONEACLRecord(data []byte) int {
+	msg := new(EACLRecord)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoEACLTable(data []byte) int {
+	msg := new(EACLTable)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONEACLTable(data []byte) int {
+	msg := new(EACLTable)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoBearerToken(data []byte) int {
+	msg := new(BearerToken)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONBearerToken(data []byte) int {
+	msg := new(BearerToken)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/acl/grpc/types_frostfs_test.go

@@ -0,0 +1,41 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package acl
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoEACLRecord(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoEACLRecord(data)
+	})
+}
+func FuzzJSONEACLRecord(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONEACLRecord(data)
+	})
+}
+func FuzzProtoEACLTable(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoEACLTable(data)
+	})
+}
+func FuzzJSONEACLTable(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONEACLTable(data)
+	})
+}
+func FuzzProtoBearerToken(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoBearerToken(data)
+	})
+}
+func FuzzJSONBearerToken(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONBearerToken(data)
+	})
+}

api/acl/json.go

@@ -0,0 +1,70 @@
+package acl
+
+import (
+	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (f *HeaderFilter) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(f)
+}
+
+func (f *HeaderFilter) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(f, data, new(acl.EACLRecord_Filter))
+}
+
+func (t *Target) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(t)
+}
+
+func (t *Target) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(t, data, new(acl.EACLRecord_Target))
+}
+
+func (a *APEOverride) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(a)
+}
+
+func (a *APEOverride) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(a, data, new(acl.BearerToken_Body_APEOverride))
+}
+
+func (r *Record) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(r)
+}
+
+func (r *Record) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(r, data, new(acl.EACLRecord))
+}
+
+func (t *Table) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(t)
+}
+
+func (t *Table) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(t, data, new(acl.EACLTable))
+}
+
+func (l *TokenLifetime) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(l)
+}
+
+func (l *TokenLifetime) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(l, data, new(acl.BearerToken_Body_TokenLifetime))
+}
+
+func (bt *BearerTokenBody) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(bt)
+}
+
+func (bt *BearerTokenBody) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(bt, data, new(acl.BearerToken_Body))
+}
+
+func (bt *BearerToken) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(bt)
+}
+
+func (bt *BearerToken) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(bt, data, new(acl.BearerToken))
+}

api/acl/marshal.go

@@ -0,0 +1,350 @@
+package acl
+
+import (
+	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	protoutil "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
+)
+
+const (
+	filterHeaderTypeField = 1
+	filterMatchTypeField  = 2
+	filterNameField       = 3
+	filterValueField      = 4
+
+	targetTypeField = 1
+	targetKeysField = 2
+
+	recordOperationField = 1
+	recordActionField    = 2
+	recordFiltersField   = 3
+	recordTargetsField   = 4
+
+	tableVersionField     = 1
+	tableContainerIDField = 2
+	tableRecordsField     = 3
+
+	lifetimeExpirationField     = 1
+	lifetimeNotValidBeforeField = 2
+	lifetimeIssuedAtField       = 3
+
+	tokenAPEChainsTargetField = 1
+	tokenAPEChainsChainsField = 2
+
+	bearerTokenBodyACLField        = 1
+	bearerTokenBodyOwnerField      = 2
+	bearerTokenBodyLifetimeField   = 3
+	bearerTokenBodyImpersonate     = 4
+	bearerTokenTokenAPEChainsField = 5
+
+	bearerTokenBodyField      = 1
+	bearerTokenSignatureField = 2
+)
+
+// StableMarshal marshals unified acl table structure in a protobuf
+// compatible way without field order shuffle.
+func (t *Table) StableMarshal(buf []byte) []byte {
+	if t == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, t.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(tableVersionField, buf[offset:], t.version)
+	offset += protoutil.NestedStructureMarshal(tableContainerIDField, buf[offset:], t.cid)
+
+	for i := range t.records {
+		offset += protoutil.NestedStructureMarshal(tableRecordsField, buf[offset:], &t.records[i])
+	}
+
+	return buf
+}
+
+// StableSize of acl table structure marshalled by StableMarshal function.
+func (t *Table) StableSize() (size int) {
+	if t == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(tableVersionField, t.version)
+	size += protoutil.NestedStructureSize(tableContainerIDField, t.cid)
+
+	for i := range t.records {
+		size += protoutil.NestedStructureSize(tableRecordsField, &t.records[i])
+	}
+
+	return size
+}
+
+func (t *Table) Unmarshal(data []byte) error {
+	return message.Unmarshal(t, data, new(acl.EACLTable))
+}
+
+// StableMarshal marshals unified acl record structure in a protobuf
+// compatible way without field order shuffle.
+func (r *Record) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.EnumMarshal(recordOperationField, buf[offset:], int32(r.op))
+	offset += protoutil.EnumMarshal(recordActionField, buf[offset:], int32(r.action))
+
+	for i := range r.filters {
+		offset += protoutil.NestedStructureMarshal(recordFiltersField, buf[offset:], &r.filters[i])
+	}
+
+	for i := range r.targets {
+		offset += protoutil.NestedStructureMarshal(recordTargetsField, buf[offset:], &r.targets[i])
+	}
+
+	return buf
+}
+
+// StableSize of acl record structure marshalled by StableMarshal function.
+func (r *Record) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	size += protoutil.EnumSize(recordOperationField, int32(r.op))
+	size += protoutil.EnumSize(recordActionField, int32(r.action))
+
+	for i := range r.filters {
+		size += protoutil.NestedStructureSize(recordFiltersField, &r.filters[i])
+	}
+
+	for i := range r.targets {
+		size += protoutil.NestedStructureSize(recordTargetsField, &r.targets[i])
+	}
+
+	return size
+}
+
+func (r *Record) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(acl.EACLRecord))
+}
+
+// StableMarshal marshals unified header filter structure in a protobuf
+// compatible way without field order shuffle.
+func (f *HeaderFilter) StableMarshal(buf []byte) []byte {
+	if f == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, f.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.EnumMarshal(filterHeaderTypeField, buf[offset:], int32(f.hdrType))
+	offset += protoutil.EnumMarshal(filterMatchTypeField, buf[offset:], int32(f.matchType))
+	offset += protoutil.StringMarshal(filterNameField, buf[offset:], f.key)
+	protoutil.StringMarshal(filterValueField, buf[offset:], f.value)
+
+	return buf
+}
+
+// StableSize of header filter structure marshalled by StableMarshal function.
+func (f *HeaderFilter) StableSize() (size int) {
+	if f == nil {
+		return 0
+	}
+
+	size += protoutil.EnumSize(filterHeaderTypeField, int32(f.hdrType))
+	size += protoutil.EnumSize(filterMatchTypeField, int32(f.matchType))
+	size += protoutil.StringSize(filterNameField, f.key)
+	size += protoutil.StringSize(filterValueField, f.value)
+
+	return size
+}
+
+func (f *HeaderFilter) Unmarshal(data []byte) error {
+	return message.Unmarshal(f, data, new(acl.EACLRecord_Filter))
+}
+
+// StableMarshal marshals unified role info structure in a protobuf
+// compatible way without field order shuffle.
+func (t *Target) StableMarshal(buf []byte) []byte {
+	if t == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, t.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.EnumMarshal(targetTypeField, buf[offset:], int32(t.role))
+	protoutil.RepeatedBytesMarshal(targetKeysField, buf[offset:], t.keys)
+
+	return buf
+}
+
+// StableSize of role info structure marshalled by StableMarshal function.
+func (t *Target) StableSize() (size int) {
+	if t == nil {
+		return 0
+	}
+
+	size += protoutil.EnumSize(targetTypeField, int32(t.role))
+	size += protoutil.RepeatedBytesSize(targetKeysField, t.keys)
+
+	return size
+}
+
+func (t *Target) Unmarshal(data []byte) error {
+	return message.Unmarshal(t, data, new(acl.EACLRecord_Target))
+}
+
+func (l *TokenLifetime) StableMarshal(buf []byte) []byte {
+	if l == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, l.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.UInt64Marshal(lifetimeExpirationField, buf[offset:], l.exp)
+	offset += protoutil.UInt64Marshal(lifetimeNotValidBeforeField, buf[offset:], l.nbf)
+	protoutil.UInt64Marshal(lifetimeIssuedAtField, buf[offset:], l.iat)
+
+	return buf
+}
+
+func (l *TokenLifetime) StableSize() (size int) {
+	if l == nil {
+		return 0
+	}
+
+	size += protoutil.UInt64Size(lifetimeExpirationField, l.exp)
+	size += protoutil.UInt64Size(lifetimeNotValidBeforeField, l.nbf)
+	size += protoutil.UInt64Size(lifetimeIssuedAtField, l.iat)
+
+	return size
+}
+
+func (l *TokenLifetime) Unmarshal(data []byte) error {
+	return message.Unmarshal(l, data, new(acl.BearerToken_Body_TokenLifetime))
+}
+
+func (c *APEOverride) StableMarshal(buf []byte) []byte {
+	if c == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, c.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(tokenAPEChainsTargetField, buf[offset:], c.target)
+	for i := range c.chains {
+		offset += protoutil.NestedStructureMarshal(tokenAPEChainsChainsField, buf[offset:], c.chains[i])
+	}
+
+	return buf
+}
+
+func (c *APEOverride) StableSize() (size int) {
+	if c == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(tokenAPEChainsTargetField, c.target)
+	for i := range c.chains {
+		size += protoutil.NestedStructureSize(tokenAPEChainsChainsField, c.chains[i])
+	}
+
+	return size
+}
+
+func (c *APEOverride) Unmarshal(data []byte) error {
+	return message.Unmarshal(c, data, new(acl.BearerToken_Body_APEOverride))
+}
+
+func (bt *BearerTokenBody) StableMarshal(buf []byte) []byte {
+	if bt == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, bt.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(bearerTokenBodyACLField, buf[offset:], bt.eacl)
+	offset += protoutil.NestedStructureMarshal(bearerTokenBodyOwnerField, buf[offset:], bt.ownerID)
+	offset += protoutil.NestedStructureMarshal(bearerTokenBodyLifetimeField, buf[offset:], bt.lifetime)
+	offset += protoutil.BoolMarshal(bearerTokenBodyImpersonate, buf[offset:], bt.impersonate)
+	protoutil.NestedStructureMarshal(bearerTokenTokenAPEChainsField, buf[offset:], bt.apeOverride)
+
+	return buf
+}
+
+func (bt *BearerTokenBody) StableSize() (size int) {
+	if bt == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(bearerTokenBodyACLField, bt.eacl)
+	size += protoutil.NestedStructureSize(bearerTokenBodyOwnerField, bt.ownerID)
+	size += protoutil.NestedStructureSize(bearerTokenBodyLifetimeField, bt.lifetime)
+	size += protoutil.BoolSize(bearerTokenBodyImpersonate, bt.impersonate)
+	size += protoutil.NestedStructureSize(bearerTokenTokenAPEChainsField, bt.apeOverride)
+
+	return size
+}
+
+func (bt *BearerTokenBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(bt, data, new(acl.BearerToken_Body))
+}
+
+func (bt *BearerToken) StableMarshal(buf []byte) []byte {
+	if bt == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, bt.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(bearerTokenBodyField, buf[offset:], bt.body)
+	protoutil.NestedStructureMarshal(bearerTokenSignatureField, buf[offset:], bt.sig)
+
+	return buf
+}
+
+func (bt *BearerToken) StableSize() (size int) {
+	if bt == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(bearerTokenBodyField, bt.body)
+	size += protoutil.NestedStructureSize(bearerTokenSignatureField, bt.sig)
+
+	return size
+}
+
+func (bt *BearerToken) Unmarshal(data []byte) error {
+	return message.Unmarshal(bt, data, new(acl.BearerToken))
+}

api/acl/message_test.go

@@ -0,0 +1,21 @@
+package acl_test
+
+import (
+	"testing"
+
+	acltest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
+)
+
+func TestMessageConvert(t *testing.T) {
+	messagetest.TestRPCMessage(t,
+		func(empty bool) message.Message { return acltest.GenerateFilter(empty) },
+		func(empty bool) message.Message { return acltest.GenerateTarget(empty) },
+		func(empty bool) message.Message { return acltest.GenerateRecord(empty) },
+		func(empty bool) message.Message { return acltest.GenerateTable(empty) },
+		func(empty bool) message.Message { return acltest.GenerateTokenLifetime(empty) },
+		func(empty bool) message.Message { return acltest.GenerateBearerTokenBody(empty) },
+		func(empty bool) message.Message { return acltest.GenerateBearerToken(empty) },
+	)
+}

api/acl/string.go

@@ -0,0 +1,110 @@
+package acl
+
+import (
+	acl "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl/grpc"
+)
+
+// String returns string representation of Action.
+func (x Action) String() string {
+	return ActionToGRPCField(x).String()
+}
+
+// FromString parses Action from a string representation.
+// It is a reverse action to String().
+//
+// Returns true if s was parsed successfully.
+func (x *Action) FromString(s string) bool {
+	var g acl.Action
+
+	ok := g.FromString(s)
+
+	if ok {
+		*x = ActionFromGRPCField(g)
+	}
+
+	return ok
+}
+
+// String returns string representation of Role.
+func (x Role) String() string {
+	return RoleToGRPCField(x).String()
+}
+
+// FromString parses Role from a string representation.
+// It is a reverse action to String().
+//
+// Returns true if s was parsed successfully.
+func (x *Role) FromString(s string) bool {
+	var g acl.Role
+
+	ok := g.FromString(s)
+
+	if ok {
+		*x = RoleFromGRPCField(g)
+	}
+
+	return ok
+}
+
+// String returns string representation of Operation.
+func (x Operation) String() string {
+	return OperationToGRPCField(x).String()
+}
+
+// FromString parses Operation from a string representation.
+// It is a reverse action to String().
+//
+// Returns true if s was parsed successfully.
+func (x *Operation) FromString(s string) bool {
+	var g acl.Operation
+
+	ok := g.FromString(s)
+
+	if ok {
+		*x = OperationFromGRPCField(g)
+	}
+
+	return ok
+}
+
+// String returns string representation of MatchType.
+func (x MatchType) String() string {
+	return MatchTypeToGRPCField(x).String()
+}
+
+// FromString parses MatchType from a string representation.
+// It is a reverse action to String().
+//
+// Returns true if s was parsed successfully.
+func (x *MatchType) FromString(s string) bool {
+	var g acl.MatchType
+
+	ok := g.FromString(s)
+
+	if ok {
+		*x = MatchTypeFromGRPCField(g)
+	}
+
+	return ok
+}
+
+// String returns string representation of HeaderType.
+func (x HeaderType) String() string {
+	return HeaderTypeToGRPCField(x).String()
+}
+
+// FromString parses HeaderType from a string representation.
+// It is a reverse action to String().
+//
+// Returns true if s was parsed successfully.
+func (x *HeaderType) FromString(s string) bool {
+	var g acl.HeaderType
+
+	ok := g.FromString(s)
+
+	if ok {
+		*x = HeaderTypeFromGRPCField(g)
+	}
+
+	return ok
+}

api/acl/test/generate.go

@@ -0,0 +1,144 @@
+package acltest
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/acl"
+	apetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/test"
+	accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/test"
+)
+
+func GenerateBearerToken(empty bool) *acl.BearerToken {
+	m := new(acl.BearerToken)
+
+	if !empty {
+		m.SetBody(GenerateBearerTokenBody(false))
+	}
+
+	m.SetSignature(accountingtest.GenerateSignature(empty))
+
+	return m
+}
+
+func GenerateBearerTokenBody(empty bool) *acl.BearerTokenBody {
+	m := new(acl.BearerTokenBody)
+
+	if !empty {
+		m.SetOwnerID(accountingtest.GenerateOwnerID(false))
+		m.SetLifetime(GenerateTokenLifetime(false))
+		m.SetAPEOverride(GenerateAPEOverride(empty))
+	}
+
+	return m
+}
+
+func GenerateAPEOverride(empty bool) *acl.APEOverride {
+	var m *acl.APEOverride
+
+	if !empty {
+		m = new(acl.APEOverride)
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+		m.SetChains(apetest.GenerateRawChains(false, 3))
+	}
+
+	return m
+}
+
+func GenerateTable(empty bool) *acl.Table {
+	m := new(acl.Table)
+
+	if !empty {
+		m.SetRecords(GenerateRecords(false))
+		m.SetContainerID(accountingtest.GenerateContainerID(false))
+	}
+
+	m.SetVersion(accountingtest.GenerateVersion(empty))
+
+	return m
+}
+
+func GenerateRecords(empty bool) []acl.Record {
+	var rs []acl.Record
+
+	if !empty {
+		rs = append(rs,
+			*GenerateRecord(false),
+			*GenerateRecord(false),
+		)
+	}
+
+	return rs
+}
+
+func GenerateRecord(empty bool) *acl.Record {
+	m := new(acl.Record)
+
+	if !empty {
+		m.SetAction(acl.ActionAllow)
+		m.SetOperation(acl.OperationGet)
+		m.SetFilters(GenerateFilters(false))
+		m.SetTargets(GenerateTargets(false))
+	}
+
+	return m
+}
+
+func GenerateFilters(empty bool) []acl.HeaderFilter {
+	var fs []acl.HeaderFilter
+
+	if !empty {
+		fs = append(fs,
+			*GenerateFilter(false),
+			*GenerateFilter(false),
+		)
+	}
+
+	return fs
+}
+
+func GenerateFilter(empty bool) *acl.HeaderFilter {
+	m := new(acl.HeaderFilter)
+
+	if !empty {
+		m.SetKey("key")
+		m.SetValue("val")
+		m.SetHeaderType(acl.HeaderTypeRequest)
+		m.SetMatchType(acl.MatchTypeStringEqual)
+	}
+
+	return m
+}
+
+func GenerateTargets(empty bool) []acl.Target {
+	var ts []acl.Target
+
+	if !empty {
+		ts = append(ts,
+			*GenerateTarget(false),
+			*GenerateTarget(false),
+		)
+	}
+
+	return ts
+}
+
+func GenerateTarget(empty bool) *acl.Target {
+	m := new(acl.Target)
+
+	if !empty {
+		m.SetRole(acl.RoleSystem)
+		m.SetKeys([][]byte{{1}, {2}})
+	}
+
+	return m
+}
+
+func GenerateTokenLifetime(empty bool) *acl.TokenLifetime {
+	m := new(acl.TokenLifetime)
+
+	if !empty {
+		m.SetExp(1)
+		m.SetIat(2)
+		m.SetExp(3)
+	}
+
+	return m
+}

api/acl/types.go

@@ -0,0 +1,426 @@
+package acl
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
+)
+
+// HeaderFilter is a unified structure of FilterInfo
+// message from proto definition.
+type HeaderFilter struct {
+	hdrType HeaderType
+
+	matchType MatchType
+
+	key, value string
+}
+
+// Target is a unified structure of Target
+// message from proto definition.
+type Target struct {
+	role Role
+
+	keys [][]byte
+}
+
+// Record is a unified structure of EACLRecord
+// message from proto definition.
+type Record struct {
+	op Operation
+
+	action Action
+
+	filters []HeaderFilter
+
+	targets []Target
+}
+
+// Table is a unified structure of EACLTable
+// message from proto definition.
+type Table struct {
+	version *refs.Version
+
+	cid *refs.ContainerID
+
+	records []Record
+}
+
+type TokenLifetime struct {
+	exp, nbf, iat uint64
+}
+
+type APEOverride struct {
+	target *ape.ChainTarget
+
+	chains []*ape.Chain
+}
+
+type BearerTokenBody struct {
+	eacl *Table
+
+	ownerID *refs.OwnerID
+
+	lifetime *TokenLifetime
+
+	apeOverride *APEOverride
+
+	impersonate bool
+}
+
+type BearerToken struct {
+	body *BearerTokenBody
+
+	sig *refs.Signature
+}
+
+// Target is a unified enum of MatchType enum from proto definition.
+type MatchType uint32
+
+// HeaderType is a unified enum of HeaderType enum from proto definition.
+type HeaderType uint32
+
+// Action is a unified enum of Action enum from proto definition.
+type Action uint32
+
+// Operation is a unified enum of Operation enum from proto definition.
+type Operation uint32
+
+// Role is a unified enum of Role enum from proto definition.
+type Role uint32
+
+const (
+	MatchTypeUnknown MatchType = iota
+	MatchTypeStringEqual
+	MatchTypeStringNotEqual
+)
+
+const (
+	HeaderTypeUnknown HeaderType = iota
+	HeaderTypeRequest
+	HeaderTypeObject
+	HeaderTypeService
+)
+
+const (
+	ActionUnknown Action = iota
+	ActionAllow
+	ActionDeny
+)
+
+const (
+	OperationUnknown Operation = iota
+	OperationGet
+	OperationHead
+	OperationPut
+	OperationDelete
+	OperationSearch
+	OperationRange
+	OperationRangeHash
+)
+
+const (
+	RoleUnknown Role = iota
+	RoleUser
+	RoleSystem
+	RoleOthers
+)
+
+func (f *HeaderFilter) GetHeaderType() HeaderType {
+	if f != nil {
+		return f.hdrType
+	}
+
+	return HeaderTypeUnknown
+}
+
+func (f *HeaderFilter) SetHeaderType(v HeaderType) {
+	f.hdrType = v
+}
+
+func (f *HeaderFilter) GetMatchType() MatchType {
+	if f != nil {
+		return f.matchType
+	}
+
+	return MatchTypeUnknown
+}
+
+func (f *HeaderFilter) SetMatchType(v MatchType) {
+	f.matchType = v
+}
+
+func (f *HeaderFilter) GetKey() string {
+	if f != nil {
+		return f.key
+	}
+
+	return ""
+}
+
+func (f *HeaderFilter) SetKey(v string) {
+	f.key = v
+}
+
+func (f *HeaderFilter) GetValue() string {
+	if f != nil {
+		return f.value
+	}
+
+	return ""
+}
+
+func (f *HeaderFilter) SetValue(v string) {
+	f.value = v
+}
+
+func (t *Target) GetRole() Role {
+	if t != nil {
+		return t.role
+	}
+
+	return RoleUnknown
+}
+
+func (t *Target) SetRole(v Role) {
+	t.role = v
+}
+
+func (t *Target) GetKeys() [][]byte {
+	if t != nil {
+		return t.keys
+	}
+
+	return nil
+}
+
+func (t *Target) SetKeys(v [][]byte) {
+	t.keys = v
+}
+
+func (r *Record) GetOperation() Operation {
+	if r != nil {
+		return r.op
+	}
+
+	return OperationUnknown
+}
+
+func (r *Record) SetOperation(v Operation) {
+	r.op = v
+}
+
+func (r *Record) GetAction() Action {
+	if r != nil {
+		return r.action
+	}
+
+	return ActionUnknown
+}
+
+func (r *Record) SetAction(v Action) {
+	r.action = v
+}
+
+func (r *Record) GetFilters() []HeaderFilter {
+	if r != nil {
+		return r.filters
+	}
+
+	return nil
+}
+
+func (r *Record) SetFilters(v []HeaderFilter) {
+	r.filters = v
+}
+
+func (r *Record) GetTargets() []Target {
+	if r != nil {
+		return r.targets
+	}
+
+	return nil
+}
+
+func (r *Record) SetTargets(v []Target) {
+	r.targets = v
+}
+
+func (t *Table) GetVersion() *refs.Version {
+	if t != nil {
+		return t.version
+	}
+
+	return nil
+}
+
+func (t *Table) SetVersion(v *refs.Version) {
+	t.version = v
+}
+
+func (t *Table) GetContainerID() *refs.ContainerID {
+	if t != nil {
+		return t.cid
+	}
+
+	return nil
+}
+
+func (t *Table) SetContainerID(v *refs.ContainerID) {
+	t.cid = v
+}
+
+func (t *Table) GetRecords() []Record {
+	if t != nil {
+		return t.records
+	}
+
+	return nil
+}
+
+func (t *Table) SetRecords(v []Record) {
+	t.records = v
+}
+
+func (l *TokenLifetime) GetExp() uint64 {
+	if l != nil {
+		return l.exp
+	}
+
+	return 0
+}
+
+func (l *TokenLifetime) SetExp(v uint64) {
+	l.exp = v
+}
+
+func (l *TokenLifetime) GetNbf() uint64 {
+	if l != nil {
+		return l.nbf
+	}
+
+	return 0
+}
+
+func (l *TokenLifetime) SetNbf(v uint64) {
+	l.nbf = v
+}
+
+func (l *TokenLifetime) GetIat() uint64 {
+	if l != nil {
+		return l.iat
+	}
+
+	return 0
+}
+
+func (l *TokenLifetime) SetIat(v uint64) {
+	l.iat = v
+}
+
+func (bt *BearerTokenBody) GetEACL() *Table {
+	if bt != nil {
+		return bt.eacl
+	}
+
+	return nil
+}
+
+func (bt *BearerTokenBody) SetEACL(v *Table) {
+	bt.eacl = v
+}
+
+func (t *APEOverride) GetTarget() *ape.ChainTarget {
+	if t == nil {
+		return nil
+	}
+
+	return t.target
+}
+
+func (t *APEOverride) GetChains() []*ape.Chain {
+	if t == nil {
+		return nil
+	}
+
+	return t.chains
+}
+
+func (t *APEOverride) SetTarget(v *ape.ChainTarget) {
+	t.target = v
+}
+
+func (t *APEOverride) SetChains(v []*ape.Chain) {
+	t.chains = v
+}
+
+func (bt *BearerTokenBody) GetAPEOverride() *APEOverride {
+	if bt != nil {
+		return bt.apeOverride
+	}
+
+	return nil
+}
+
+func (bt *BearerTokenBody) SetAPEOverride(v *APEOverride) {
+	bt.apeOverride = v
+}
+
+func (bt *BearerTokenBody) GetOwnerID() *refs.OwnerID {
+	if bt != nil {
+		return bt.ownerID
+	}
+
+	return nil
+}
+
+func (bt *BearerTokenBody) SetOwnerID(v *refs.OwnerID) {
+	bt.ownerID = v
+}
+
+func (bt *BearerTokenBody) GetLifetime() *TokenLifetime {
+	if bt != nil {
+		return bt.lifetime
+	}
+
+	return nil
+}
+
+func (bt *BearerTokenBody) SetLifetime(v *TokenLifetime) {
+	bt.lifetime = v
+}
+
+func (bt *BearerTokenBody) GetImpersonate() bool {
+	if bt != nil {
+		return bt.impersonate
+	}
+
+	return false
+}
+
+func (bt *BearerTokenBody) SetImpersonate(v bool) {
+	bt.impersonate = v
+}
+
+func (bt *BearerToken) GetBody() *BearerTokenBody {
+	if bt != nil {
+		return bt.body
+	}
+
+	return nil
+}
+
+func (bt *BearerToken) SetBody(v *BearerTokenBody) {
+	bt.body = v
+}
+
+func (bt *BearerToken) GetSignature() *refs.Signature {
+	if bt != nil {
+		return bt.sig
+	}
+
+	return nil
+}
+
+func (bt *BearerToken) SetSignature(v *refs.Signature) {
+	bt.sig = v
+}

api/ape/convert.go

@@ -0,0 +1,132 @@
+package ape
+
+import (
+	"fmt"
+
+	ape "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func TargetTypeToGRPCField(typ TargetType) ape.TargetType {
+	switch typ {
+	case TargetTypeNamespace:
+		return ape.TargetType_NAMESPACE
+	case TargetTypeContainer:
+		return ape.TargetType_CONTAINER
+	case TargetTypeUser:
+		return ape.TargetType_USER
+	case TargetTypeGroup:
+		return ape.TargetType_GROUP
+	default:
+		return ape.TargetType_UNDEFINED
+	}
+}
+
+func TargetTypeFromGRPCField(typ ape.TargetType) TargetType {
+	switch typ {
+	case ape.TargetType_NAMESPACE:
+		return TargetTypeNamespace
+	case ape.TargetType_CONTAINER:
+		return TargetTypeContainer
+	case ape.TargetType_USER:
+		return TargetTypeUser
+	case ape.TargetType_GROUP:
+		return TargetTypeGroup
+	default:
+		return TargetTypeUndefined
+	}
+}
+
+func TargetTypeToGRPC(typ TargetType) ape.TargetType {
+	return ape.TargetType(typ)
+}
+
+func TargetTypeFromGRPC(typ ape.TargetType) TargetType {
+	return TargetType(typ)
+}
+
+func (v2 *ChainTarget) ToGRPCMessage() grpc.Message {
+	var mgrpc *ape.ChainTarget
+
+	if v2 != nil {
+		mgrpc = new(ape.ChainTarget)
+
+		mgrpc.SetType(TargetTypeToGRPC(v2.GetTargetType()))
+		mgrpc.SetName(v2.GetName())
+	}
+
+	return mgrpc
+}
+
+func (v2 *ChainTarget) FromGRPCMessage(m grpc.Message) error {
+	mgrpc, ok := m.(*ape.ChainTarget)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, mgrpc)
+	}
+
+	v2.SetTargetType(TargetTypeFromGRPC(mgrpc.GetType()))
+	v2.SetName(mgrpc.GetName())
+
+	return nil
+}
+
+func (v2 *ChainRaw) ToGRPCMessage() grpc.Message {
+	var mgrpc *ape.Chain_Raw
+
+	if v2 != nil {
+		mgrpc = new(ape.Chain_Raw)
+
+		mgrpc.SetRaw(v2.GetRaw())
+	}
+
+	return mgrpc
+}
+
+func (v2 *ChainRaw) FromGRPCMessage(m grpc.Message) error {
+	mgrpc, ok := m.(*ape.Chain_Raw)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, mgrpc)
+	}
+
+	v2.SetRaw(mgrpc.GetRaw())
+
+	return nil
+}
+
+func (v2 *Chain) ToGRPCMessage() grpc.Message {
+	var mgrpc *ape.Chain
+
+	if v2 != nil {
+		mgrpc = new(ape.Chain)
+
+		switch chainKind := v2.GetKind().(type) {
+		default:
+			panic(fmt.Sprintf("unsupported chain kind: %T", chainKind))
+		case *ChainRaw:
+			mgrpc.SetKind(chainKind.ToGRPCMessage().(*ape.Chain_Raw))
+		}
+	}
+
+	return mgrpc
+}
+
+func (v2 *Chain) FromGRPCMessage(m grpc.Message) error {
+	mgrpc, ok := m.(*ape.Chain)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, mgrpc)
+	}
+
+	switch chainKind := mgrpc.GetKind().(type) {
+	default:
+		return fmt.Errorf("unsupported chain kind: %T", chainKind)
+	case *ape.Chain_Raw:
+		chainRaw := new(ChainRaw)
+		if err := chainRaw.FromGRPCMessage(chainKind); err != nil {
+			return err
+		}
+		v2.SetKind(chainRaw)
+	}
+
+	return nil
+}

api/ape/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,45 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package ape
+
+func DoFuzzProtoChainTarget(data []byte) int {
+	msg := new(ChainTarget)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONChainTarget(data []byte) int {
+	msg := new(ChainTarget)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoChain(data []byte) int {
+	msg := new(Chain)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONChain(data []byte) int {
+	msg := new(Chain)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/ape/grpc/types_frostfs_test.go

@@ -0,0 +1,31 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package ape
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoChainTarget(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoChainTarget(data)
+	})
+}
+func FuzzJSONChainTarget(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONChainTarget(data)
+	})
+}
+func FuzzProtoChain(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoChain(data)
+	})
+}
+func FuzzJSONChain(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONChain(data)
+	})
+}

api/ape/json.go

@@ -0,0 +1,14 @@
+package ape
+
+import (
+	ape "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (t *ChainTarget) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(t)
+}
+
+func (t *ChainTarget) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(t, data, new(ape.ChainTarget))
+}

api/ape/marshal.go

@@ -0,0 +1,92 @@
+package ape
+
+import (
+	"fmt"
+
+	ape "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
+)
+
+const (
+	chainTargetTargetTypeField = 1
+	chainTargetNameField       = 2
+
+	chainRawField = 1
+)
+
+func (t *ChainTarget) StableSize() (size int) {
+	if t == nil {
+		return 0
+	}
+
+	size += proto.EnumSize(chainTargetTargetTypeField, int32(t.targeType))
+	size += proto.StringSize(chainTargetNameField, t.name)
+
+	return size
+}
+
+func (t *ChainTarget) StableMarshal(buf []byte) []byte {
+	if t == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, t.StableSize())
+	}
+
+	var offset int
+
+	offset += proto.EnumMarshal(chainTargetTargetTypeField, buf[offset:], int32(t.targeType))
+	proto.StringMarshal(chainTargetNameField, buf[offset:], t.name)
+
+	return buf
+}
+
+func (t *ChainTarget) Unmarshal(data []byte) error {
+	return message.Unmarshal(t, data, new(ape.ChainTarget))
+}
+
+func (c *Chain) StableSize() (size int) {
+	if c == nil {
+		return 0
+	}
+
+	switch v := c.GetKind().(type) {
+	case *ChainRaw:
+		if v != nil {
+			size += proto.BytesSize(chainRawField, v.GetRaw())
+		}
+	default:
+		panic(fmt.Sprintf("unsupported chain kind: %T", v))
+	}
+
+	return size
+}
+
+func (c *Chain) StableMarshal(buf []byte) []byte {
+	if c == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, c.StableSize())
+	}
+
+	var offset int
+
+	switch v := c.GetKind().(type) {
+	case *ChainRaw:
+		if v != nil {
+			proto.BytesMarshal(chainRawField, buf[offset:], v.GetRaw())
+		}
+	default:
+		panic(fmt.Sprintf("unsupported chain kind: %T", v))
+	}
+
+	return buf
+}
+
+func (c *Chain) Unmarshal(data []byte) error {
+	return message.Unmarshal(c, data, new(ape.Chain))
+}

api/ape/message_test.go

@@ -0,0 +1,15 @@
+package ape_test
+
+import (
+	"testing"
+
+	apetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
+)
+
+func TestMessageConvert(t *testing.T) {
+	messagetest.TestRPCMessage(t,
+		func(empty bool) message.Message { return apetest.GenerateChainTarget(empty) },
+	)
+}

api/ape/string.go

@@ -0,0 +1,18 @@
+package ape
+
+import (
+	apegrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
+)
+
+func (tt TargetType) String() string {
+	return TargetTypeToGRPCField(tt).String()
+}
+
+func (tt *TargetType) FromString(s string) bool {
+	i, ok := apegrpc.TargetType_value[s]
+	if ok {
+		*tt = TargetType(i)
+	}
+
+	return ok
+}

api/ape/test/generate.go

@@ -0,0 +1,71 @@
+package test
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+)
+
+func GenerateRawChains(empty bool, n int) []*ape.Chain {
+	if empty {
+		return []*ape.Chain{}
+	}
+
+	res := make([]*ape.Chain, n)
+	for i := range res {
+		res[i] = GenerateRawChain(empty)
+	}
+	return res
+}
+
+func GenerateRawChain(empty bool) *ape.Chain {
+	chRaw := new(ape.ChainRaw)
+
+	if empty {
+		chRaw.SetRaw([]byte("{}"))
+	} else {
+		chRaw.SetRaw([]byte(`{
+			"ID": "",
+			"Rules": [
+			  {
+				"Status": "Allow",
+				"Actions": {
+				  "Inverted": false,
+				  "Names": [
+					"GetObject"
+				  ]
+				},
+				"Resources": {
+				  "Inverted": false,
+				  "Names": [
+					"native:object/*"
+				  ]
+				},
+				"Any": false,
+				"Condition": [
+				  {
+					"Op": "StringEquals",
+					"Object": "Resource",
+					"Key": "Department",
+					"Value": "HR"
+				  }
+				]
+			  }
+			],
+			"MatchType": "DenyPriority"
+			}`))
+	}
+
+	ch := new(ape.Chain)
+	ch.SetKind(chRaw)
+	return ch
+}
+
+func GenerateChainTarget(empty bool) *ape.ChainTarget {
+	m := new(ape.ChainTarget)
+
+	if !empty {
+		m.SetTargetType(ape.TargetTypeContainer)
+		m.SetName("BzQw5HH3feoxFDD5tCT87Y1726qzgLfxEE7wgtoRzB3R")
+	}
+
+	return m
+}

api/ape/types.go

@@ -0,0 +1,79 @@
+package ape
+
+type TargetType uint32
+
+const (
+	TargetTypeUndefined TargetType = iota
+	TargetTypeNamespace
+	TargetTypeContainer
+	TargetTypeUser
+	TargetTypeGroup
+)
+
+type ChainTarget struct {
+	targeType TargetType
+
+	name string
+}
+
+func (ct *ChainTarget) SetTargetType(targeType TargetType) {
+	ct.targeType = targeType
+}
+
+func (ct *ChainTarget) SetName(name string) {
+	ct.name = name
+}
+
+func (ct *ChainTarget) GetTargetType() TargetType {
+	if ct != nil {
+		return ct.targeType
+	}
+
+	return 0
+}
+
+func (ct *ChainTarget) GetName() string {
+	if ct != nil {
+		return ct.name
+	}
+
+	return ""
+}
+
+type chainKind interface {
+	isChainKind()
+}
+
+type Chain struct {
+	kind chainKind
+}
+
+func (c *Chain) SetKind(kind chainKind) {
+	c.kind = kind
+}
+
+func (c *Chain) GetKind() chainKind {
+	if c == nil {
+		return nil
+	}
+
+	return c.kind
+}
+
+type ChainRaw struct {
+	Raw []byte
+}
+
+func (*ChainRaw) isChainKind() {}
+
+func (c *ChainRaw) SetRaw(raw []byte) {
+	c.Raw = raw
+}
+
+func (c *ChainRaw) GetRaw() []byte {
+	if c == nil {
+		return nil
+	}
+
+	return c.Raw
+}

api/apemanager/convert.go

@@ -0,0 +1,358 @@
+package apemanager
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+	apeGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/grpc"
+	apemanager "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (reqBody *AddChainRequestBody) ToGRPCMessage() grpc.Message {
+	var reqBodygrpc *apemanager.AddChainRequest_Body
+
+	if reqBody != nil {
+		reqBodygrpc = new(apemanager.AddChainRequest_Body)
+
+		reqBodygrpc.SetTarget(reqBody.GetTarget().ToGRPCMessage().(*apeGRPC.ChainTarget))
+		reqBodygrpc.SetChain(reqBody.GetChain().ToGRPCMessage().(*apeGRPC.Chain))
+	}
+
+	return reqBodygrpc
+}
+
+func (reqBody *AddChainRequestBody) FromGRPCMessage(m grpc.Message) error {
+	reqBodygrpc, ok := m.(*apemanager.AddChainRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqBodygrpc)
+	}
+
+	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
+		reqBody.target = new(ape.ChainTarget)
+		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
+			return err
+		}
+	}
+
+	if chaingrpc := reqBodygrpc.GetChain(); chaingrpc != nil {
+		reqBody.chain = new(ape.Chain)
+		if err := reqBody.GetChain().FromGRPCMessage(chaingrpc); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (req *AddChainRequest) ToGRPCMessage() grpc.Message {
+	var reqgrpc *apemanager.AddChainRequest
+
+	if req != nil {
+		reqgrpc = new(apemanager.AddChainRequest)
+
+		reqgrpc.SetBody(req.GetBody().ToGRPCMessage().(*apemanager.AddChainRequest_Body))
+		req.RequestHeaders.ToMessage(reqgrpc)
+	}
+
+	return reqgrpc
+}
+
+func (req *AddChainRequest) FromGRPCMessage(m grpc.Message) error {
+	reqgrpc, ok := m.(*apemanager.AddChainRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqgrpc)
+	}
+
+	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
+		req.body = new(AddChainRequestBody)
+		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return req.RequestHeaders.FromMessage(reqgrpc)
+}
+
+func (respBody *AddChainResponseBody) ToGRPCMessage() grpc.Message {
+	var respBodygrpc *apemanager.AddChainResponse_Body
+
+	if respBody != nil {
+		respBodygrpc = new(apemanager.AddChainResponse_Body)
+
+		respBodygrpc.SetChainId(respBody.GetChainID())
+	}
+
+	return respBodygrpc
+}
+
+func (respBody *AddChainResponseBody) FromGRPCMessage(m grpc.Message) error {
+	respBodygrpc, ok := m.(*apemanager.AddChainResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respBodygrpc)
+	}
+
+	respBody.SetChainID(respBodygrpc.GetChainId())
+
+	return nil
+}
+
+func (resp *AddChainResponse) ToGRPCMessage() grpc.Message {
+	var respgrpc *apemanager.AddChainResponse
+
+	if resp != nil {
+		respgrpc = new(apemanager.AddChainResponse)
+
+		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.AddChainResponse_Body))
+		resp.ResponseHeaders.ToMessage(respgrpc)
+	}
+
+	return respgrpc
+}
+
+func (resp *AddChainResponse) FromGRPCMessage(m grpc.Message) error {
+	respgrpc, ok := m.(*apemanager.AddChainResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respgrpc)
+	}
+
+	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
+		resp.body = new(AddChainResponseBody)
+		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return resp.ResponseHeaders.FromMessage(respgrpc)
+}
+
+func (reqBody *RemoveChainRequestBody) ToGRPCMessage() grpc.Message {
+	var reqBodygrpc *apemanager.RemoveChainRequest_Body
+
+	if reqBody != nil {
+		reqBodygrpc = new(apemanager.RemoveChainRequest_Body)
+
+		reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
+		reqBodygrpc.SetChainId(reqBody.GetChainID())
+	}
+
+	return reqBodygrpc
+}
+
+func (reqBody *RemoveChainRequestBody) FromGRPCMessage(m grpc.Message) error {
+	reqBodygrpc, ok := m.(*apemanager.RemoveChainRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqBodygrpc)
+	}
+
+	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
+		reqBody.target = new(ape.ChainTarget)
+		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
+			return err
+		}
+	}
+
+	reqBody.SetChainID(reqBodygrpc.GetChainId())
+
+	return nil
+}
+
+func (req *RemoveChainRequest) ToGRPCMessage() grpc.Message {
+	var reqgrpc *apemanager.RemoveChainRequest
+
+	if req != nil {
+		reqgrpc = new(apemanager.RemoveChainRequest)
+
+		reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.RemoveChainRequest_Body))
+		req.RequestHeaders.ToMessage(reqgrpc)
+	}
+
+	return reqgrpc
+}
+
+func (req *RemoveChainRequest) FromGRPCMessage(m grpc.Message) error {
+	reqgrpc, ok := m.(*apemanager.RemoveChainRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqgrpc)
+	}
+
+	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
+		req.body = new(RemoveChainRequestBody)
+		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return req.RequestHeaders.FromMessage(reqgrpc)
+}
+
+func (respBody *RemoveChainResponseBody) ToGRPCMessage() grpc.Message {
+	var respBodygrpc *apemanager.RemoveChainResponse_Body
+
+	if respBody != nil {
+		respBodygrpc = new(apemanager.RemoveChainResponse_Body)
+	}
+
+	return respBodygrpc
+}
+
+func (respBody *RemoveChainResponseBody) FromGRPCMessage(m grpc.Message) error {
+	respBodygrpc, ok := m.(*apemanager.RemoveChainResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respBodygrpc)
+	}
+
+	return nil
+}
+
+func (resp *RemoveChainResponse) ToGRPCMessage() grpc.Message {
+	var respgrpc *apemanager.RemoveChainResponse
+
+	if resp != nil {
+		respgrpc = new(apemanager.RemoveChainResponse)
+
+		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.RemoveChainResponse_Body))
+		resp.ResponseHeaders.ToMessage(respgrpc)
+	}
+
+	return respgrpc
+}
+
+func (resp *RemoveChainResponse) FromGRPCMessage(m grpc.Message) error {
+	respgrpc, ok := m.(*apemanager.RemoveChainResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respgrpc)
+	}
+
+	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
+		resp.body = new(RemoveChainResponseBody)
+		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return resp.ResponseHeaders.FromMessage(respgrpc)
+}
+
+func (reqBody *ListChainsRequestBody) ToGRPCMessage() grpc.Message {
+	var reqBodygrpc *apemanager.ListChainsRequest_Body
+
+	if reqBody != nil {
+		reqBodygrpc = new(apemanager.ListChainsRequest_Body)
+
+		reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
+	}
+
+	return reqBodygrpc
+}
+
+func (reqBody *ListChainsRequestBody) FromGRPCMessage(m grpc.Message) error {
+	reqBodygrpc, ok := m.(*apemanager.ListChainsRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqBodygrpc)
+	}
+
+	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
+		reqBody.target = new(ape.ChainTarget)
+		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (req *ListChainsRequest) ToGRPCMessage() grpc.Message {
+	var reqgrpc *apemanager.ListChainsRequest
+
+	if req != nil {
+		reqgrpc = new(apemanager.ListChainsRequest)
+
+		reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.ListChainsRequest_Body))
+		req.RequestHeaders.ToMessage(reqgrpc)
+	}
+
+	return reqgrpc
+}
+
+func (req *ListChainsRequest) FromGRPCMessage(m grpc.Message) error {
+	reqgrpc, ok := m.(*apemanager.ListChainsRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqgrpc)
+	}
+
+	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
+		req.body = new(ListChainsRequestBody)
+		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return req.RequestHeaders.FromMessage(reqgrpc)
+}
+
+func (respBody *ListChainsResponseBody) ToGRPCMessage() grpc.Message {
+	var respBodygrpc *apemanager.ListChainsResponse_Body
+
+	if respBody != nil {
+		respBodygrpc = new(apemanager.ListChainsResponse_Body)
+
+		chainsgrpc := make([]apeGRPC.Chain, 0, len(respBody.GetChains()))
+		for _, chain := range respBody.GetChains() {
+			chainsgrpc = append(chainsgrpc, *chain.ToGRPCMessage().(*apeGRPC.Chain))
+		}
+
+		respBodygrpc.SetChains(chainsgrpc)
+	}
+
+	return respBodygrpc
+}
+
+func (respBody *ListChainsResponseBody) FromGRPCMessage(m grpc.Message) error {
+	respBodygrpc, ok := m.(*apemanager.ListChainsResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respBodygrpc)
+	}
+
+	chains := make([]*ape.Chain, 0, len(respBodygrpc.GetChains()))
+
+	for _, chaingrpc := range respBodygrpc.GetChains() {
+		chain := new(ape.Chain)
+		if err := chain.FromGRPCMessage(&chaingrpc); err != nil {
+			return err
+		}
+		chains = append(chains, chain)
+	}
+
+	respBody.SetChains(chains)
+
+	return nil
+}
+
+func (resp *ListChainsResponse) ToGRPCMessage() grpc.Message {
+	var respgrpc *apemanager.ListChainsResponse
+
+	if resp != nil {
+		respgrpc = new(apemanager.ListChainsResponse)
+
+		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.ListChainsResponse_Body))
+		resp.ResponseHeaders.ToMessage(respgrpc)
+	}
+
+	return respgrpc
+}
+
+func (resp *ListChainsResponse) FromGRPCMessage(m grpc.Message) error {
+	respgrpc, ok := m.(*apemanager.ListChainsResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respgrpc)
+	}
+
+	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
+		resp.body = new(ListChainsResponseBody)
+		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return resp.ResponseHeaders.FromMessage(respgrpc)
+}

api/apemanager/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,121 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package apemanager
+
+func DoFuzzProtoAddChainRequest(data []byte) int {
+	msg := new(AddChainRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONAddChainRequest(data []byte) int {
+	msg := new(AddChainRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoAddChainResponse(data []byte) int {
+	msg := new(AddChainResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONAddChainResponse(data []byte) int {
+	msg := new(AddChainResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoRemoveChainRequest(data []byte) int {
+	msg := new(RemoveChainRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONRemoveChainRequest(data []byte) int {
+	msg := new(RemoveChainRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoRemoveChainResponse(data []byte) int {
+	msg := new(RemoveChainResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONRemoveChainResponse(data []byte) int {
+	msg := new(RemoveChainResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListChainsRequest(data []byte) int {
+	msg := new(ListChainsRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListChainsRequest(data []byte) int {
+	msg := new(ListChainsRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListChainsResponse(data []byte) int {
+	msg := new(ListChainsResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListChainsResponse(data []byte) int {
+	msg := new(ListChainsResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/apemanager/grpc/service_frostfs_test.go

@@ -0,0 +1,71 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package apemanager
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoAddChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoAddChainRequest(data)
+	})
+}
+func FuzzJSONAddChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONAddChainRequest(data)
+	})
+}
+func FuzzProtoAddChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoAddChainResponse(data)
+	})
+}
+func FuzzJSONAddChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONAddChainResponse(data)
+	})
+}
+func FuzzProtoRemoveChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoRemoveChainRequest(data)
+	})
+}
+func FuzzJSONRemoveChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONRemoveChainRequest(data)
+	})
+}
+func FuzzProtoRemoveChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoRemoveChainResponse(data)
+	})
+}
+func FuzzJSONRemoveChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONRemoveChainResponse(data)
+	})
+}
+func FuzzProtoListChainsRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListChainsRequest(data)
+	})
+}
+func FuzzJSONListChainsRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListChainsRequest(data)
+	})
+}
+func FuzzProtoListChainsResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListChainsResponse(data)
+	})
+}
+func FuzzJSONListChainsResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListChainsResponse(data)
+	})
+}

api/apemanager/marshal.go

@@ -0,0 +1,205 @@
+package apemanager
+
+import (
+	apemanager "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
+)
+
+const (
+	addChainReqBodyTargetField = 1
+	addChainReqBodyChainField  = 2
+
+	addChainRespBodyChainIDField = 1
+
+	removeChainReqBodyTargetField = 1
+	removeChainReqBodyChainField  = 2
+
+	/*
+		Fields for RemoveResponseBody are missed since RemoveResponseBody is empty.
+	*/
+
+	listChainsReqBodyTargetField = 1
+
+	listChainsRespBodyChainsField = 1
+)
+
+func (rb *AddChainRequestBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.NestedStructureSize(addChainReqBodyTargetField, rb.target)
+	size += proto.NestedStructureSize(addChainReqBodyChainField, rb.chain)
+
+	return size
+}
+
+func (rb *AddChainRequestBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+
+	offset += proto.NestedStructureMarshal(addChainReqBodyTargetField, buf[offset:], rb.target)
+	proto.NestedStructureMarshal(addChainReqBodyChainField, buf[offset:], rb.chain)
+
+	return buf
+}
+
+func (rb *AddChainRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.AddChainRequest_Body))
+}
+
+func (rb *AddChainResponseBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.BytesSize(addChainRespBodyChainIDField, rb.chainID)
+
+	return size
+}
+
+func (rb *AddChainResponseBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+
+	proto.BytesMarshal(addChainRespBodyChainIDField, buf[offset:], rb.chainID)
+
+	return buf
+}
+
+func (rb *AddChainResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.AddChainResponse_Body))
+}
+
+func (rb *RemoveChainRequestBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.NestedStructureSize(addChainReqBodyTargetField, rb.target)
+	size += proto.BytesSize(addChainReqBodyChainField, rb.chainID)
+
+	return size
+}
+
+func (rb *RemoveChainRequestBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+
+	offset += proto.NestedStructureMarshal(removeChainReqBodyTargetField, buf[offset:], rb.target)
+	proto.BytesMarshal(removeChainReqBodyChainField, buf[offset:], rb.chainID)
+
+	return buf
+}
+
+func (rb *RemoveChainRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.RemoveChainRequest_Body))
+}
+
+func (rb *RemoveChainResponseBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	return size
+}
+
+func (rb *RemoveChainResponseBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	return buf
+}
+
+func (rb *RemoveChainResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.RemoveChainResponse_Body))
+}
+
+func (rb *ListChainsRequestBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.NestedStructureSize(listChainsReqBodyTargetField, rb.target)
+
+	return size
+}
+
+func (rb *ListChainsRequestBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+	proto.NestedStructureMarshal(addChainReqBodyTargetField, buf[offset:], rb.target)
+
+	return buf
+}
+
+func (rb *ListChainsRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.ListChainsRequest_Body))
+}
+
+func (rb *ListChainsResponseBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	for _, chain := range rb.GetChains() {
+		size += proto.NestedStructureSize(listChainsRespBodyChainsField, chain)
+	}
+
+	return size
+}
+
+func (rb *ListChainsResponseBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+	for _, chain := range rb.GetChains() {
+		offset += proto.NestedStructureMarshal(listChainsRespBodyChainsField, buf[offset:], chain)
+	}
+
+	return buf
+}
+
+func (rb *ListChainsResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.ListChainsResponse_Body))
+}

api/apemanager/message_test.go

@@ -0,0 +1,26 @@
+package apemanager_test
+
+import (
+	"testing"
+
+	apemanagertest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
+)
+
+func TestMessageConvert(t *testing.T) {
+	messagetest.TestRPCMessage(t,
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainRequestBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainRequest(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainResponseBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainResponse(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainRequestBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainRequest(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainResponseBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainResponse(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsRequestBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsRequest(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsResponseBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsResponse(empty) },
+	)
+}

api/apemanager/status.go

@@ -0,0 +1,76 @@
+package apemanager
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status"
+	statusgrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/grpc"
+)
+
+// LocalizeFailStatus checks if passed global status.Code is related to ape manager failure and:
+//
+//	then localizes the code and returns true,
+//	else leaves the code unchanged and returns false.
+//
+// Arg must be non-nil.
+func LocalizeFailStatus(c *status.Code) bool {
+	return status.LocalizeIfInSection(c, uint32(statusgrpc.Section_SECTION_APE_MANAGER))
+}
+
+// GlobalizeFail globalizes local code of ape manager failure.
+//
+// Arg must be non-nil.
+func GlobalizeFail(c *status.Code) {
+	c.GlobalizeSection(uint32(statusgrpc.Section_SECTION_APE_MANAGER))
+}
+
+const (
+	// StatusAPEManagerAccessDenied is a local status.Code value for
+	// ACCESS_DENIED ape manager failure.
+	StatusAPEManagerAccessDenied status.Code = iota
+)
+
+const (
+	// detailAccessDeniedDesc is a StatusAccessDenied detail ID for
+	// human-readable description.
+	detailAccessDeniedDesc = iota
+)
+
+// WriteAccessDeniedDesc writes human-readable description of StatusAccessDenied
+// into status.Status as a detail. The status must not be nil.
+//
+// Existing details are expected to be ID-unique, otherwise undefined behavior.
+func WriteAccessDeniedDesc(st *status.Status, desc string) {
+	var found bool
+
+	st.IterateDetails(func(d *status.Detail) bool {
+		if d.ID() == detailAccessDeniedDesc {
+			found = true
+			d.SetValue([]byte(desc))
+		}
+
+		return found
+	})
+
+	if !found {
+		var d status.Detail
+
+		d.SetID(detailAccessDeniedDesc)
+		d.SetValue([]byte(desc))
+
+		st.AppendDetails(d)
+	}
+}
+
+// ReadAccessDeniedDesc looks up for status detail with human-readable description
+// of StatusAccessDenied. Returns empty string if detail is missing.
+func ReadAccessDeniedDesc(st status.Status) (desc string) {
+	st.IterateDetails(func(d *status.Detail) bool {
+		if d.ID() == detailAccessDeniedDesc {
+			desc = string(d.Value())
+			return true
+		}
+
+		return false
+	})
+
+	return
+}

api/apemanager/status_test.go

@@ -0,0 +1,30 @@
+package apemanager_test
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status"
+	statustest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/test"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStatusCodes(t *testing.T) {
+	statustest.TestCodes(t, apemanager.LocalizeFailStatus, apemanager.GlobalizeFail,
+		apemanager.StatusAPEManagerAccessDenied, 5120,
+	)
+}
+
+func TestAccessDeniedDesc(t *testing.T) {
+	var st status.Status
+
+	require.Empty(t, apemanager.ReadAccessDeniedDesc(st))
+
+	const desc = "some description"
+
+	apemanager.WriteAccessDeniedDesc(&st, desc)
+	require.Equal(t, desc, apemanager.ReadAccessDeniedDesc(st))
+
+	apemanager.WriteAccessDeniedDesc(&st, desc+"1")
+	require.Equal(t, desc+"1", apemanager.ReadAccessDeniedDesc(st))
+}

api/apemanager/test/generate.go

@@ -0,0 +1,143 @@
+package apemanagertest
+
+import (
+	apetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/apemanager"
+	sessiontest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/test"
+)
+
+func generateChainID(empty bool) []byte {
+	if empty {
+		return []byte{}
+	}
+
+	return []byte("616c6c6f774f626a476574436e72")
+}
+
+func GenerateAddChainRequestBody(empty bool) *apemanager.AddChainRequestBody {
+	m := new(apemanager.AddChainRequestBody)
+
+	if !empty {
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+		m.SetChain(apetest.GenerateRawChain(empty))
+	}
+
+	return m
+}
+
+func GenerateAddChainRequest(empty bool) *apemanager.AddChainRequest {
+	m := new(apemanager.AddChainRequest)
+
+	if !empty {
+		m.SetBody(GenerateAddChainRequestBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateAddChainResponseBody(empty bool) *apemanager.AddChainResponseBody {
+	m := new(apemanager.AddChainResponseBody)
+
+	if !empty {
+		m.SetChainID(generateChainID(empty))
+	}
+
+	return m
+}
+
+func GenerateAddChainResponse(empty bool) *apemanager.AddChainResponse {
+	m := new(apemanager.AddChainResponse)
+
+	if !empty {
+		m.SetBody(GenerateAddChainResponseBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateRemoveChainRequestBody(empty bool) *apemanager.RemoveChainRequestBody {
+	m := new(apemanager.RemoveChainRequestBody)
+
+	if !empty {
+		m.SetChainID(generateChainID(empty))
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+	}
+
+	return m
+}
+
+func GenerateRemoveChainRequest(empty bool) *apemanager.RemoveChainRequest {
+	m := new(apemanager.RemoveChainRequest)
+
+	if !empty {
+		m.SetBody(GenerateRemoveChainRequestBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateRemoveChainResponseBody(_ bool) *apemanager.RemoveChainResponseBody {
+	return new(apemanager.RemoveChainResponseBody)
+}
+
+func GenerateRemoveChainResponse(empty bool) *apemanager.RemoveChainResponse {
+	m := new(apemanager.RemoveChainResponse)
+
+	if !empty {
+		m.SetBody(GenerateRemoveChainResponseBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateListChainsRequestBody(empty bool) *apemanager.ListChainsRequestBody {
+	m := new(apemanager.ListChainsRequestBody)
+
+	if !empty {
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+	}
+
+	return m
+}
+
+func GenerateListChainsRequest(empty bool) *apemanager.ListChainsRequest {
+	m := new(apemanager.ListChainsRequest)
+
+	if !empty {
+		m.SetBody(GenerateListChainsRequestBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateListChainsResponseBody(empty bool) *apemanager.ListChainsResponseBody {
+	m := new(apemanager.ListChainsResponseBody)
+
+	if !empty {
+		m.SetChains(apetest.GenerateRawChains(empty, 10))
+	}
+
+	return m
+}
+
+func GenerateListChainsResponse(empty bool) *apemanager.ListChainsResponse {
+	m := new(apemanager.ListChainsResponse)
+
+	if !empty {
+		m.SetBody(GenerateListChainsResponseBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+	}
+
+	return m
+}

api/apemanager/types.go

@@ -0,0 +1,226 @@
+package apemanager
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/ape"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
+)
+
+type AddChainRequest struct {
+	body *AddChainRequestBody
+
+	session.RequestHeaders
+}
+
+func (r *AddChainRequest) SetBody(body *AddChainRequestBody) {
+	r.body = body
+}
+
+func (r *AddChainRequest) GetBody() *AddChainRequestBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type AddChainRequestBody struct {
+	target *ape.ChainTarget
+
+	chain *ape.Chain
+}
+
+func (rb *AddChainRequestBody) SetTarget(target *ape.ChainTarget) {
+	rb.target = target
+}
+
+func (rb *AddChainRequestBody) GetTarget() *ape.ChainTarget {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.target
+}
+
+func (rb *AddChainRequestBody) SetChain(chain *ape.Chain) {
+	rb.chain = chain
+}
+
+func (rb *AddChainRequestBody) GetChain() *ape.Chain {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.chain
+}
+
+type AddChainResponse struct {
+	body *AddChainResponseBody
+
+	session.ResponseHeaders
+}
+
+func (r *AddChainResponse) SetBody(body *AddChainResponseBody) {
+	r.body = body
+}
+
+func (r *AddChainResponse) GetBody() *AddChainResponseBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type AddChainResponseBody struct {
+	chainID []byte
+}
+
+func (rb *AddChainResponseBody) SetChainID(chainID []byte) {
+	rb.chainID = chainID
+}
+
+func (rb *AddChainResponseBody) GetChainID() []byte {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.chainID
+}
+
+type RemoveChainRequest struct {
+	body *RemoveChainRequestBody
+
+	session.RequestHeaders
+}
+
+func (r *RemoveChainRequest) SetBody(body *RemoveChainRequestBody) {
+	r.body = body
+}
+
+func (r *RemoveChainRequest) GetBody() *RemoveChainRequestBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type RemoveChainRequestBody struct {
+	target *ape.ChainTarget
+
+	chainID []byte
+}
+
+func (rb *RemoveChainRequestBody) SetTarget(target *ape.ChainTarget) {
+	rb.target = target
+}
+
+func (rb *RemoveChainRequestBody) GetTarget() *ape.ChainTarget {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.target
+}
+
+func (rb *RemoveChainRequestBody) SetChainID(chainID []byte) {
+	rb.chainID = chainID
+}
+
+func (rb *RemoveChainRequestBody) GetChainID() []byte {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.chainID
+}
+
+type RemoveChainResponse struct {
+	body *RemoveChainResponseBody
+
+	session.ResponseHeaders
+}
+
+type RemoveChainResponseBody struct{}
+
+func (r *RemoveChainResponse) SetBody(body *RemoveChainResponseBody) {
+	r.body = body
+}
+
+func (r *RemoveChainResponse) GetBody() *RemoveChainResponseBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type ListChainsRequest struct {
+	body *ListChainsRequestBody
+
+	session.RequestHeaders
+}
+
+func (r *ListChainsRequest) SetBody(body *ListChainsRequestBody) {
+	r.body = body
+}
+
+func (r *ListChainsRequest) GetBody() *ListChainsRequestBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type ListChainsRequestBody struct {
+	target *ape.ChainTarget
+}
+
+func (rb *ListChainsRequestBody) SetTarget(target *ape.ChainTarget) {
+	rb.target = target
+}
+
+func (rb *ListChainsRequestBody) GetTarget() *ape.ChainTarget {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.target
+}
+
+type ListChainsResponse struct {
+	body *ListChainsResponseBody
+
+	session.ResponseHeaders
+}
+
+func (r *ListChainsResponse) SetBody(body *ListChainsResponseBody) {
+	r.body = body
+}
+
+func (r *ListChainsResponse) GetBody() *ListChainsResponseBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type ListChainsResponseBody struct {
+	chains []*ape.Chain
+
+	session.RequestHeaders
+}
+
+func (r *ListChainsResponseBody) SetChains(chains []*ape.Chain) {
+	r.chains = chains
+}
+
+func (r *ListChainsResponseBody) GetChains() []*ape.Chain {
+	if r == nil {
+		return nil
+	}
+
+	return r.chains
+}

api/container/attributes.go

@@ -0,0 +1,90 @@
+package container
+
+// SysAttributePrefix is a prefix of key to system attribute.
+const SysAttributePrefix = "__SYSTEM__"
+
+const (
+	// SysAttributeName is a string of human-friendly container name registered as the domain in NNS contract.
+	SysAttributeName = SysAttributePrefix + "NAME"
+
+	// SysAttributeZone is a string of zone for container name.
+	SysAttributeZone = SysAttributePrefix + "ZONE"
+
+	// SysAttributeHomomorphicHashing is a container's homomorphic hashing state.
+	SysAttributeHomomorphicHashing = SysAttributePrefix + "DISABLE_HOMOMORPHIC_HASHING"
+)
+
+// SysAttributePrefixNeoFS is a prefix of key to system attribute.
+// Deprecated: use SysAttributePrefix.
+const SysAttributePrefixNeoFS = "__NEOFS__"
+
+const (
+	// SysAttributeNameNeoFS is a string of human-friendly container name registered as the domain in NNS contract.
+	// Deprecated: use SysAttributeName.
+	SysAttributeNameNeoFS = SysAttributePrefixNeoFS + "NAME"
+
+	// SysAttributeZoneNeoFS is a string of zone for container name.
+	// Deprecated: use SysAttributeZone.
+	SysAttributeZoneNeoFS = SysAttributePrefixNeoFS + "ZONE"
+
+	// SysAttributeHomomorphicHashingNeoFS is a container's homomorphic hashing state.
+	// Deprecated: use SysAttributeHomomorphicHashing.
+	SysAttributeHomomorphicHashingNeoFS = SysAttributePrefixNeoFS + "DISABLE_HOMOMORPHIC_HASHING"
+)
+
+// SysAttributeZoneDefault is a default value for SysAttributeZone attribute.
+const SysAttributeZoneDefault = "container"
+
+const disabledHomomorphicHashingValue = "true"
+
+// HomomorphicHashingState returns container's homomorphic
+// hashing state:
+//   - true if hashing is enabled;
+//   - false if hashing is disabled.
+//
+// All container's attributes must be unique, otherwise behavior
+// is undefined.
+//
+// See also SetHomomorphicHashingState.
+func (c Container) HomomorphicHashingState() bool {
+	for i := range c.attr {
+		if c.attr[i].GetKey() == SysAttributeHomomorphicHashing || c.attr[i].GetKey() == SysAttributeHomomorphicHashingNeoFS {
+			return c.attr[i].GetValue() != disabledHomomorphicHashingValue
+		}
+	}
+
+	return true
+}
+
+// SetHomomorphicHashingState sets homomorphic hashing state for
+// container.
+//
+// All container's attributes must be unique, otherwise behavior
+// is undefined.
+//
+// See also HomomorphicHashingState.
+func (c *Container) SetHomomorphicHashingState(enable bool) {
+	for i := range c.attr {
+		if c.attr[i].GetKey() == SysAttributeHomomorphicHashing || c.attr[i].GetKey() == SysAttributeHomomorphicHashingNeoFS {
+			if enable {
+				// approach without allocation/waste
+				// coping works since the attributes
+				// order is not important
+				c.attr[i] = c.attr[len(c.attr)-1]
+				c.attr = c.attr[:len(c.attr)-1]
+			} else {
+				c.attr[i].SetValue(disabledHomomorphicHashingValue)
+			}
+
+			return
+		}
+	}
+
+	if !enable {
+		attr := Attribute{}
+		attr.SetKey(SysAttributeHomomorphicHashing)
+		attr.SetValue(disabledHomomorphicHashingValue)
+
+		c.attr = append(c.attr, attr)
+	}
+}

api/container/attributes_test.go

@@ -0,0 +1,59 @@
+package container_test
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container"
+	containertest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/test"
+	"github.com/stretchr/testify/require"
+)
+
+func TestContainer_HomomorphicHashingDisabled(t *testing.T) {
+	cnr := containertest.GenerateContainer(false)
+
+	t.Run("defaults", func(t *testing.T) {
+		require.True(t, cnr.HomomorphicHashingState())
+	})
+
+	t.Run("disabled", func(t *testing.T) {
+		attr := container.Attribute{}
+		attr.SetKey(container.SysAttributeHomomorphicHashing)
+		attr.SetValue("NOT_true")
+
+		cnr.SetAttributes(append(cnr.GetAttributes(), attr))
+		require.True(t, cnr.HomomorphicHashingState())
+
+		attr.SetValue("true")
+
+		cnr.SetAttributes([]container.Attribute{attr})
+		require.False(t, cnr.HomomorphicHashingState())
+	})
+}
+
+func TestContainer_SetHomomorphicHashingState(t *testing.T) {
+	cnr := containertest.GenerateContainer(false)
+	attrs := cnr.GetAttributes()
+	attrLen := len(attrs)
+
+	cnr.SetHomomorphicHashingState(true)
+
+	// enabling hashing should not add any new attributes
+	require.Equal(t, attrLen, len(cnr.GetAttributes()))
+	require.True(t, cnr.HomomorphicHashingState())
+
+	cnr.SetHomomorphicHashingState(false)
+
+	// disabling hashing should add exactly one attribute
+	require.Equal(t, attrLen+1, len(cnr.GetAttributes()))
+	require.False(t, cnr.HomomorphicHashingState())
+
+	cnr.SetHomomorphicHashingState(true)
+
+	// enabling hashing should remove 1 attribute if
+	// hashing was disabled before
+	require.Equal(t, attrLen, len(cnr.GetAttributes()))
+	require.True(t, cnr.HomomorphicHashingState())
+
+	// hashing operations should not change any other attributes
+	require.ElementsMatch(t, attrs, cnr.GetAttributes())
+}

api/container/convert.go

@@ -0,0 +1,764 @@
+package container
+
+import (
+	container "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap"
+	netmapGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
+	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
+	sessionGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/grpc"
+)
+
+func (a *Attribute) ToGRPCMessage() grpc.Message {
+	var m *container.Container_Attribute
+
+	if a != nil {
+		m = new(container.Container_Attribute)
+
+		m.SetKey(a.key)
+		m.SetValue(a.val)
+	}
+
+	return m
+}
+
+func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.Container_Attribute)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	a.key = v.GetKey()
+	a.val = v.GetValue()
+
+	return nil
+}
+
+func AttributesToGRPC(xs []Attribute) (res []container.Container_Attribute) {
+	if xs != nil {
+		res = make([]container.Container_Attribute, 0, len(xs))
+
+		for i := range xs {
+			res = append(res, *xs[i].ToGRPCMessage().(*container.Container_Attribute))
+		}
+	}
+
+	return
+}
+
+func AttributesFromGRPC(xs []container.Container_Attribute) (res []Attribute, err error) {
+	if xs != nil {
+		res = make([]Attribute, len(xs))
+
+		for i := range xs {
+			err = res[i].FromGRPCMessage(&xs[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (c *Container) ToGRPCMessage() grpc.Message {
+	var m *container.Container
+
+	if c != nil {
+		m = new(container.Container)
+
+		m.SetVersion(c.version.ToGRPCMessage().(*refsGRPC.Version))
+		m.SetOwnerId(c.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
+		m.SetPlacementPolicy(c.policy.ToGRPCMessage().(*netmapGRPC.PlacementPolicy))
+		m.SetAttributes(AttributesToGRPC(c.attr))
+		m.SetBasicAcl(c.basicACL)
+		m.SetNonce(c.nonce)
+	}
+
+	return m
+}
+
+func (c *Container) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.Container)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	version := v.GetVersion()
+	if version == nil {
+		c.version = nil
+	} else {
+		if c.version == nil {
+			c.version = new(refs.Version)
+		}
+
+		err = c.version.FromGRPCMessage(version)
+		if err != nil {
+			return err
+		}
+	}
+
+	ownerID := v.GetOwnerId()
+	if ownerID == nil {
+		c.ownerID = nil
+	} else {
+		if c.ownerID == nil {
+			c.ownerID = new(refs.OwnerID)
+		}
+
+		err = c.ownerID.FromGRPCMessage(ownerID)
+		if err != nil {
+			return err
+		}
+	}
+
+	policy := v.GetPlacementPolicy()
+	if policy == nil {
+		c.policy = nil
+	} else {
+		if c.policy == nil {
+			c.policy = new(netmap.PlacementPolicy)
+		}
+
+		err = c.policy.FromGRPCMessage(policy)
+		if err != nil {
+			return err
+		}
+	}
+
+	c.attr, err = AttributesFromGRPC(v.GetAttributes())
+	if err != nil {
+		return err
+	}
+
+	c.basicACL = v.GetBasicAcl()
+	c.nonce = v.GetNonce()
+
+	return nil
+}
+
+func toSignatureRFC6979(s *refs.Signature) *refsGRPC.SignatureRFC6979 {
+	var res *refsGRPC.SignatureRFC6979
+
+	if s != nil {
+		res = new(refsGRPC.SignatureRFC6979)
+		res.SetKey(s.GetKey())
+		res.SetSign(s.GetSign())
+	}
+
+	return res
+}
+
+func (r *PutRequestBody) ToGRPCMessage() grpc.Message {
+	var m *container.PutRequest_Body
+
+	if r != nil {
+		m = new(container.PutRequest_Body)
+
+		m.SetContainer(r.cnr.ToGRPCMessage().(*container.Container))
+		m.SetSignature(toSignatureRFC6979(r.sig))
+	}
+
+	return m
+}
+
+func (r *PutRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.PutRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	cnr := v.GetContainer()
+	if cnr == nil {
+		r.cnr = nil
+	} else {
+		if r.cnr == nil {
+			r.cnr = new(Container)
+		}
+
+		err = r.cnr.FromGRPCMessage(cnr)
+		if err != nil {
+			return err
+		}
+	}
+
+	sig := v.GetSignature()
+	if sig == nil {
+		r.sig = nil
+	} else {
+		if r.sig == nil {
+			r.sig = new(refs.Signature)
+		}
+
+		r.sig.SetKey(sig.GetKey())
+		r.sig.SetSign(sig.GetSign())
+	}
+
+	return err
+}
+
+func (r *PutRequest) ToGRPCMessage() grpc.Message {
+	var m *container.PutRequest
+
+	if r != nil {
+		m = new(container.PutRequest)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.PutRequest_Body))
+		r.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *PutRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.PutRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(PutRequestBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.RequestHeaders.FromMessage(v)
+}
+
+func (r *PutResponseBody) ToGRPCMessage() grpc.Message {
+	var m *container.PutResponse_Body
+
+	if r != nil {
+		m = new(container.PutResponse_Body)
+
+		m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
+	}
+
+	return m
+}
+
+func (r *PutResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.PutResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	cid := v.GetContainerId()
+	if cid == nil {
+		r.cid = nil
+	} else {
+		if r.cid == nil {
+			r.cid = new(refs.ContainerID)
+		}
+
+		err = r.cid.FromGRPCMessage(cid)
+	}
+
+	return err
+}
+
+func (r *PutResponse) ToGRPCMessage() grpc.Message {
+	var m *container.PutResponse
+
+	if r != nil {
+		m = new(container.PutResponse)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.PutResponse_Body))
+		r.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *PutResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.PutResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(PutResponseBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.ResponseHeaders.FromMessage(v)
+}
+
+func (r *GetRequestBody) ToGRPCMessage() grpc.Message {
+	var m *container.GetRequest_Body
+
+	if r != nil {
+		m = new(container.GetRequest_Body)
+
+		m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
+	}
+
+	return m
+}
+
+func (r *GetRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.GetRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	cid := v.GetContainerId()
+	if cid == nil {
+		r.cid = nil
+	} else {
+		if r.cid == nil {
+			r.cid = new(refs.ContainerID)
+		}
+
+		err = r.cid.FromGRPCMessage(cid)
+	}
+
+	return err
+}
+
+func (r *GetRequest) ToGRPCMessage() grpc.Message {
+	var m *container.GetRequest
+
+	if r != nil {
+		m = new(container.GetRequest)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.GetRequest_Body))
+		r.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *GetRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.GetRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(GetRequestBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.RequestHeaders.FromMessage(v)
+}
+
+func (r *GetResponseBody) ToGRPCMessage() grpc.Message {
+	var m *container.GetResponse_Body
+
+	if r != nil {
+		m = new(container.GetResponse_Body)
+
+		m.SetContainer(r.cnr.ToGRPCMessage().(*container.Container))
+		m.SetSessionToken(r.token.ToGRPCMessage().(*sessionGRPC.SessionToken))
+		m.SetSignature(toSignatureRFC6979(r.sig))
+	}
+
+	return m
+}
+
+func (r *GetResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.GetResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	cnr := v.GetContainer()
+	if cnr == nil {
+		r.cnr = nil
+	} else {
+		if r.cnr == nil {
+			r.cnr = new(Container)
+		}
+
+		err = r.cnr.FromGRPCMessage(cnr)
+	}
+
+	sig := v.GetSignature()
+	if sig == nil {
+		r.sig = nil
+	} else {
+		if r.sig == nil {
+			r.sig = new(refs.Signature)
+		}
+
+		r.sig.SetKey(sig.GetKey())
+		r.sig.SetSign(sig.GetSign())
+	}
+
+	token := v.GetSessionToken()
+	if token == nil {
+		r.token = nil
+	} else {
+		if r.token == nil {
+			r.token = new(session.Token)
+		}
+
+		err = r.token.FromGRPCMessage(token)
+	}
+
+	return err
+}
+
+func (r *GetResponse) ToGRPCMessage() grpc.Message {
+	var m *container.GetResponse
+
+	if r != nil {
+		m = new(container.GetResponse)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.GetResponse_Body))
+		r.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *GetResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.GetResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(GetResponseBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.ResponseHeaders.FromMessage(v)
+}
+
+func (r *DeleteRequestBody) ToGRPCMessage() grpc.Message {
+	var m *container.DeleteRequest_Body
+
+	if r != nil {
+		m = new(container.DeleteRequest_Body)
+
+		m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
+		m.SetSignature(toSignatureRFC6979(r.sig))
+	}
+
+	return m
+}
+
+func (r *DeleteRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.DeleteRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	cid := v.GetContainerId()
+	if cid == nil {
+		r.cid = nil
+	} else {
+		if r.cid == nil {
+			r.cid = new(refs.ContainerID)
+		}
+
+		err = r.cid.FromGRPCMessage(cid)
+		if err != nil {
+			return err
+		}
+	}
+
+	sig := v.GetSignature()
+	if sig == nil {
+		r.sig = nil
+	} else {
+		if r.sig == nil {
+			r.sig = new(refs.Signature)
+		}
+
+		r.sig.SetKey(sig.GetKey())
+		r.sig.SetSign(sig.GetSign())
+	}
+
+	return err
+}
+
+func (r *DeleteRequest) ToGRPCMessage() grpc.Message {
+	var m *container.DeleteRequest
+
+	if r != nil {
+		m = new(container.DeleteRequest)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.DeleteRequest_Body))
+		r.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *DeleteRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.DeleteRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(DeleteRequestBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.RequestHeaders.FromMessage(v)
+}
+
+func (r *DeleteResponseBody) ToGRPCMessage() grpc.Message {
+	var m *container.DeleteResponse_Body
+
+	if r != nil {
+		m = new(container.DeleteResponse_Body)
+	}
+
+	return m
+}
+
+func (r *DeleteResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.DeleteResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	return nil
+}
+
+func (r *DeleteResponse) ToGRPCMessage() grpc.Message {
+	var m *container.DeleteResponse
+
+	if r != nil {
+		m = new(container.DeleteResponse)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.DeleteResponse_Body))
+		r.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *DeleteResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.DeleteResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(DeleteResponseBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.ResponseHeaders.FromMessage(v)
+}
+
+func (r *ListRequestBody) ToGRPCMessage() grpc.Message {
+	var m *container.ListRequest_Body
+
+	if r != nil {
+		m = new(container.ListRequest_Body)
+
+		m.SetOwnerId(r.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
+	}
+
+	return m
+}
+
+func (r *ListRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.ListRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	ownerID := v.GetOwnerId()
+	if ownerID == nil {
+		r.ownerID = nil
+	} else {
+		if r.ownerID == nil {
+			r.ownerID = new(refs.OwnerID)
+		}
+
+		err = r.ownerID.FromGRPCMessage(ownerID)
+	}
+
+	return err
+}
+
+func (r *ListRequest) ToGRPCMessage() grpc.Message {
+	var m *container.ListRequest
+
+	if r != nil {
+		m = new(container.ListRequest)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.ListRequest_Body))
+		r.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *ListRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.ListRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(ListRequestBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.RequestHeaders.FromMessage(v)
+}
+
+func (r *ListResponseBody) ToGRPCMessage() grpc.Message {
+	var m *container.ListResponse_Body
+
+	if r != nil {
+		m = new(container.ListResponse_Body)
+
+		m.SetContainerIds(refs.ContainerIDsToGRPCMessage(r.cidList))
+	}
+
+	return m
+}
+
+func (r *ListResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.ListResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	r.cidList, err = refs.ContainerIDsFromGRPCMessage(v.GetContainerIds())
+
+	return err
+}
+
+func (r *ListResponse) ToGRPCMessage() grpc.Message {
+	var m *container.ListResponse
+
+	if r != nil {
+		m = new(container.ListResponse)
+
+		m.SetBody(r.body.ToGRPCMessage().(*container.ListResponse_Body))
+		r.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (r *ListResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*container.ListResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		r.body = nil
+	} else {
+		if r.body == nil {
+			r.body = new(ListResponseBody)
+		}
+
+		err = r.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.ResponseHeaders.FromMessage(v)
+}

api/container/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,159 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+func DoFuzzProtoPutRequest(data []byte) int {
+	msg := new(PutRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONPutRequest(data []byte) int {
+	msg := new(PutRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoPutResponse(data []byte) int {
+	msg := new(PutResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONPutResponse(data []byte) int {
+	msg := new(PutResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoDeleteRequest(data []byte) int {
+	msg := new(DeleteRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONDeleteRequest(data []byte) int {
+	msg := new(DeleteRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoDeleteResponse(data []byte) int {
+	msg := new(DeleteResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONDeleteResponse(data []byte) int {
+	msg := new(DeleteResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoGetRequest(data []byte) int {
+	msg := new(GetRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONGetRequest(data []byte) int {
+	msg := new(GetRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoGetResponse(data []byte) int {
+	msg := new(GetResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONGetResponse(data []byte) int {
+	msg := new(GetResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListRequest(data []byte) int {
+	msg := new(ListRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListRequest(data []byte) int {
+	msg := new(ListRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListResponse(data []byte) int {
+	msg := new(ListResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListResponse(data []byte) int {
+	msg := new(ListResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/container/grpc/service_frostfs_test.go

@@ -0,0 +1,91 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoPutRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoPutRequest(data)
+	})
+}
+func FuzzJSONPutRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONPutRequest(data)
+	})
+}
+func FuzzProtoPutResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoPutResponse(data)
+	})
+}
+func FuzzJSONPutResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONPutResponse(data)
+	})
+}
+func FuzzProtoDeleteRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoDeleteRequest(data)
+	})
+}
+func FuzzJSONDeleteRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONDeleteRequest(data)
+	})
+}
+func FuzzProtoDeleteResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoDeleteResponse(data)
+	})
+}
+func FuzzJSONDeleteResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONDeleteResponse(data)
+	})
+}
+func FuzzProtoGetRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoGetRequest(data)
+	})
+}
+func FuzzJSONGetRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONGetRequest(data)
+	})
+}
+func FuzzProtoGetResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoGetResponse(data)
+	})
+}
+func FuzzJSONGetResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONGetResponse(data)
+	})
+}
+func FuzzProtoListRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListRequest(data)
+	})
+}
+func FuzzJSONListRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListRequest(data)
+	})
+}
+func FuzzProtoListResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListResponse(data)
+	})
+}
+func FuzzJSONListResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListResponse(data)
+	})
+}

api/container/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,26 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+func DoFuzzProtoContainer(data []byte) int {
+	msg := new(Container)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONContainer(data []byte) int {
+	msg := new(Container)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/container/grpc/types_frostfs_test.go

@@ -0,0 +1,21 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoContainer(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoContainer(data)
+	})
+}
+func FuzzJSONContainer(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONContainer(data)
+	})
+}

api/container/json.go

@@ -0,0 +1,22 @@
+package container
+
+import (
+	container "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (a *Attribute) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(a)
+}
+
+func (a *Attribute) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(a, data, new(container.Container_Attribute))
+}
+
+func (c *Container) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(c)
+}
+
+func (c *Container) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(c, data, new(container.Container))
+}

api/container/marshal.go

@@ -0,0 +1,345 @@
+package container
+
+import (
+	container "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	protoutil "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/util/proto"
+)
+
+const (
+	attributeKeyField   = 1
+	attributeValueField = 2
+
+	containerVersionField    = 1
+	containerOwnerField      = 2
+	containerNonceField      = 3
+	containerBasicACLField   = 4
+	containerAttributesField = 5
+	containerPlacementField  = 6
+
+	putReqBodyContainerField = 1
+	putReqBodySignatureField = 2
+
+	putRespBodyIDField = 1
+
+	deleteReqBodyIDField        = 1
+	deleteReqBodySignatureField = 2
+
+	getReqBodyIDField = 1
+
+	getRespBodyContainerField = 1
+	getRespBodySignatureField = 2
+	getRespBodyTokenField     = 3
+
+	listReqBodyOwnerField = 1
+
+	listRespBodyIDsField = 1
+)
+
+func (a *Attribute) StableMarshal(buf []byte) []byte {
+	if a == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, a.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.StringMarshal(attributeKeyField, buf[offset:], a.key)
+	protoutil.StringMarshal(attributeValueField, buf[offset:], a.val)
+
+	return buf
+}
+
+func (a *Attribute) StableSize() (size int) {
+	if a == nil {
+		return 0
+	}
+
+	size += protoutil.StringSize(attributeKeyField, a.key)
+	size += protoutil.StringSize(attributeValueField, a.val)
+
+	return size
+}
+
+func (a *Attribute) Unmarshal(data []byte) error {
+	return message.Unmarshal(a, data, new(container.Container_Attribute))
+}
+
+func (c *Container) StableMarshal(buf []byte) []byte {
+	if c == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, c.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(containerVersionField, buf[offset:], c.version)
+	offset += protoutil.NestedStructureMarshal(containerOwnerField, buf[offset:], c.ownerID)
+	offset += protoutil.BytesMarshal(containerNonceField, buf[offset:], c.nonce)
+	offset += protoutil.UInt32Marshal(containerBasicACLField, buf[offset:], c.basicACL)
+
+	for i := range c.attr {
+		offset += protoutil.NestedStructureMarshal(containerAttributesField, buf[offset:], &c.attr[i])
+	}
+
+	protoutil.NestedStructureMarshal(containerPlacementField, buf[offset:], c.policy)
+
+	return buf
+}
+
+func (c *Container) StableSize() (size int) {
+	if c == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(containerVersionField, c.version)
+	size += protoutil.NestedStructureSize(containerOwnerField, c.ownerID)
+	size += protoutil.BytesSize(containerNonceField, c.nonce)
+	size += protoutil.UInt32Size(containerBasicACLField, c.basicACL)
+
+	for i := range c.attr {
+		size += protoutil.NestedStructureSize(containerAttributesField, &c.attr[i])
+	}
+
+	size += protoutil.NestedStructureSize(containerPlacementField, c.policy)
+
+	return size
+}
+
+func (c *Container) Unmarshal(data []byte) error {
+	return message.Unmarshal(c, data, new(container.Container))
+}
+
+func (r *PutRequestBody) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(putReqBodyContainerField, buf[offset:], r.cnr)
+	protoutil.NestedStructureMarshal(putReqBodySignatureField, buf[offset:], r.sig)
+
+	return buf
+}
+
+func (r *PutRequestBody) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(putReqBodyContainerField, r.cnr)
+	size += protoutil.NestedStructureSize(putReqBodySignatureField, r.sig)
+
+	return size
+}
+
+func (r *PutRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(container.PutRequest_Body))
+}
+
+func (r *PutResponseBody) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	protoutil.NestedStructureMarshal(putRespBodyIDField, buf, r.cid)
+
+	return buf
+}
+
+func (r *PutResponseBody) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(putRespBodyIDField, r.cid)
+
+	return size
+}
+
+func (r *PutResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(container.PutResponse_Body))
+}
+
+func (r *DeleteRequestBody) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(deleteReqBodyIDField, buf[offset:], r.cid)
+	protoutil.NestedStructureMarshal(deleteReqBodySignatureField, buf[offset:], r.sig)
+
+	return buf
+}
+
+func (r *DeleteRequestBody) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(deleteReqBodyIDField, r.cid)
+	size += protoutil.NestedStructureSize(deleteReqBodySignatureField, r.sig)
+
+	return size
+}
+
+func (r *DeleteRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(container.DeleteRequest_Body))
+}
+
+func (r *DeleteResponseBody) StableMarshal(_ []byte) []byte {
+	return nil
+}
+
+func (r *DeleteResponseBody) StableSize() (size int) {
+	return 0
+}
+
+func (r *DeleteResponseBody) Unmarshal([]byte) error {
+	return nil
+}
+
+func (r *GetRequestBody) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	protoutil.NestedStructureMarshal(getReqBodyIDField, buf, r.cid)
+
+	return buf
+}
+
+func (r *GetRequestBody) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(getReqBodyIDField, r.cid)
+
+	return size
+}
+
+func (r *GetRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(container.GetRequest_Body))
+}
+
+func (r *GetResponseBody) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(getRespBodyContainerField, buf, r.cnr)
+	offset += protoutil.NestedStructureMarshal(getRespBodySignatureField, buf[offset:], r.sig)
+	protoutil.NestedStructureMarshal(getRespBodyTokenField, buf[offset:], r.token)
+
+	return buf
+}
+
+func (r *GetResponseBody) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(getRespBodyContainerField, r.cnr)
+	size += protoutil.NestedStructureSize(getRespBodySignatureField, r.sig)
+	size += protoutil.NestedStructureSize(getRespBodyTokenField, r.token)
+
+	return size
+}
+
+func (r *GetResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(container.GetResponse_Body))
+}
+
+func (r *ListRequestBody) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	protoutil.NestedStructureMarshal(listReqBodyOwnerField, buf, r.ownerID)
+
+	return buf
+}
+
+func (r *ListRequestBody) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(listReqBodyOwnerField, r.ownerID)
+
+	return size
+}
+
+func (r *ListRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(container.ListRequest_Body))
+}
+
+func (r *ListResponseBody) StableMarshal(buf []byte) []byte {
+	if r == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, r.StableSize())
+	}
+
+	var offset int
+
+	for i := range r.cidList {
+		offset += protoutil.NestedStructureMarshal(listRespBodyIDsField, buf[offset:], &r.cidList[i])
+	}
+
+	return buf
+}
+
+func (r *ListResponseBody) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
+	for i := range r.cidList {
+		size += protoutil.NestedStructureSize(listRespBodyIDsField, &r.cidList[i])
+	}
+
+	return size
+}
+
+func (r *ListResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(r, data, new(container.ListResponse_Body))
+}

api/container/message_test.go

@@ -0,0 +1,36 @@
+package container_test
+
+import (
+	"testing"
+
+	containertest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+	messagetest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message/test"
+)
+
+func TestMessageConvert(t *testing.T) {
+	messagetest.TestRPCMessage(t,
+		func(empty bool) message.Message { return containertest.GenerateAttribute(empty) },
+		func(empty bool) message.Message { return containertest.GenerateContainer(empty) },
+		func(empty bool) message.Message { return containertest.GeneratePutRequestBody(empty) },
+		func(empty bool) message.Message { return containertest.GeneratePutRequest(empty) },
+		func(empty bool) message.Message { return containertest.GeneratePutResponseBody(empty) },
+		func(empty bool) message.Message { return containertest.GeneratePutResponse(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetRequestBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetRequest(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetResponseBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetResponse(empty) },
+		func(empty bool) message.Message { return containertest.GenerateDeleteRequestBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateDeleteRequest(empty) },
+		func(empty bool) message.Message { return containertest.GenerateDeleteResponseBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateDeleteResponse(empty) },
+		func(empty bool) message.Message { return containertest.GenerateListRequestBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateListRequest(empty) },
+		func(empty bool) message.Message { return containertest.GenerateListResponseBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateListResponse(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetRequestBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetRequest(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetResponseBody(empty) },
+		func(empty bool) message.Message { return containertest.GenerateGetResponse(empty) },
+	)
+}

api/container/status.go

@@ -0,0 +1,33 @@
+package container
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status"
+	statusgrpc "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/grpc"
+)
+
+// LocalizeFailStatus checks if passed global status.Code is related to container failure and:
+//
+//	then localizes the code and returns true,
+//	else leaves the code unchanged and returns false.
+//
+// Arg must not be nil.
+func LocalizeFailStatus(c *status.Code) bool {
+	return status.LocalizeIfInSection(c, uint32(statusgrpc.Section_SECTION_CONTAINER))
+}
+
+// GlobalizeFail globalizes local code of container failure.
+//
+// Arg must not be nil.
+func GlobalizeFail(c *status.Code) {
+	c.GlobalizeSection(uint32(statusgrpc.Section_SECTION_CONTAINER))
+}
+
+const (
+	// StatusNotFound is a local status.Code value for
+	// CONTAINER_NOT_FOUND container failure.
+	StatusNotFound status.Code = iota
+
+	// StatusEACLNotFound is a local status.Code value for
+	// EACL_NOT_FOUND failure.
+	StatusEACLNotFound
+)

api/container/status_test.go

@@ -0,0 +1,15 @@
+package container_test
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container"
+	statustest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/status/test"
+)
+
+func TestStatusCodes(t *testing.T) {
+	statustest.TestCodes(t, container.LocalizeFailStatus, container.GlobalizeFail,
+		container.StatusNotFound, 3072,
+		container.StatusEACLNotFound, 3073,
+	)
+}

api/container/test/generate.go

@@ -0,0 +1,240 @@
+package containertest
+
+import (
+	"crypto/rand"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/container"
+	netmaptest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/test"
+	refstest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/test"
+	sessiontest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session/test"
+)
+
+func GenerateAttribute(empty bool) *container.Attribute {
+	m := new(container.Attribute)
+
+	if !empty {
+		m.SetKey("key")
+		m.SetValue("val")
+	}
+
+	return m
+}
+
+func GenerateAttributes(empty bool) []container.Attribute {
+	var res []container.Attribute
+
+	if !empty {
+		res = append(res,
+			*GenerateAttribute(false),
+			*GenerateAttribute(false),
+		)
+	}
+
+	return res
+}
+
+func GenerateContainer(empty bool) *container.Container {
+	m := new(container.Container)
+
+	if !empty {
+		nonce := make([]byte, 16)
+		_, _ = rand.Read(nonce)
+
+		m.SetBasicACL(12)
+		m.SetNonce(nonce)
+		m.SetOwnerID(refstest.GenerateOwnerID(false))
+		m.SetAttributes(GenerateAttributes(false))
+		m.SetPlacementPolicy(netmaptest.GeneratePlacementPolicy(false))
+	}
+
+	m.SetVersion(refstest.GenerateVersion(empty))
+
+	return m
+}
+
+func GeneratePutRequestBody(empty bool) *container.PutRequestBody {
+	m := new(container.PutRequestBody)
+
+	if !empty {
+		m.SetContainer(GenerateContainer(false))
+	}
+
+	m.SetSignature(refstest.GenerateSignature(empty))
+
+	return m
+}
+
+func GeneratePutRequest(empty bool) *container.PutRequest {
+	m := new(container.PutRequest)
+
+	if !empty {
+		m.SetBody(GeneratePutRequestBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+
+	return m
+}
+
+func GeneratePutResponseBody(empty bool) *container.PutResponseBody {
+	m := new(container.PutResponseBody)
+
+	if !empty {
+		m.SetContainerID(refstest.GenerateContainerID(false))
+	}
+
+	return m
+}
+
+func GeneratePutResponse(empty bool) *container.PutResponse {
+	m := new(container.PutResponse)
+
+	if !empty {
+		m.SetBody(GeneratePutResponseBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateGetRequestBody(empty bool) *container.GetRequestBody {
+	m := new(container.GetRequestBody)
+
+	if !empty {
+		m.SetContainerID(refstest.GenerateContainerID(false))
+	}
+
+	return m
+}
+
+func GenerateGetRequest(empty bool) *container.GetRequest {
+	m := new(container.GetRequest)
+
+	if !empty {
+		m.SetBody(GenerateGetRequestBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateGetResponseBody(empty bool) *container.GetResponseBody {
+	m := new(container.GetResponseBody)
+
+	if !empty {
+		m.SetContainer(GenerateContainer(false))
+	}
+
+	m.SetSignature(refstest.GenerateSignature(empty))
+	m.SetSessionToken(sessiontest.GenerateSessionToken(empty))
+
+	return m
+}
+
+func GenerateGetResponse(empty bool) *container.GetResponse {
+	m := new(container.GetResponse)
+
+	if !empty {
+		m.SetBody(GenerateGetResponseBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateDeleteRequestBody(empty bool) *container.DeleteRequestBody {
+	m := new(container.DeleteRequestBody)
+
+	if !empty {
+		m.SetContainerID(refstest.GenerateContainerID(false))
+	}
+
+	m.SetSignature(refstest.GenerateSignature(empty))
+
+	return m
+}
+
+func GenerateDeleteRequest(empty bool) *container.DeleteRequest {
+	m := new(container.DeleteRequest)
+
+	if !empty {
+		m.SetBody(GenerateDeleteRequestBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateDeleteResponseBody(_ bool) *container.DeleteResponseBody {
+	m := new(container.DeleteResponseBody)
+
+	return m
+}
+
+func GenerateDeleteResponse(empty bool) *container.DeleteResponse {
+	m := new(container.DeleteResponse)
+
+	if !empty {
+		m.SetBody(GenerateDeleteResponseBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateListRequestBody(empty bool) *container.ListRequestBody {
+	m := new(container.ListRequestBody)
+
+	if !empty {
+		m.SetOwnerID(refstest.GenerateOwnerID(false))
+	}
+
+	return m
+}
+
+func GenerateListRequest(empty bool) *container.ListRequest {
+	m := new(container.ListRequest)
+
+	if !empty {
+		m.SetBody(GenerateListRequestBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+
+	return m
+}
+
+func GenerateListResponseBody(empty bool) *container.ListResponseBody {
+	m := new(container.ListResponseBody)
+
+	if !empty {
+		m.SetContainerIDs(refstest.GenerateContainerIDs(false))
+	}
+
+	return m
+}
+
+func GenerateListResponse(empty bool) *container.ListResponse {
+	m := new(container.ListResponse)
+
+	if !empty {
+		m.SetBody(GenerateListResponseBody(false))
+	}
+
+	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+
+	return m
+}

api/container/types.go

@@ -0,0 +1,446 @@
+package container
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/session"
+)
+
+type Attribute struct {
+	key, val string
+}
+
+type Container struct {
+	version *refs.Version
+
+	ownerID *refs.OwnerID
+
+	nonce []byte
+
+	basicACL uint32
+
+	attr []Attribute
+
+	policy *netmap.PlacementPolicy
+}
+
+type PutRequestBody struct {
+	cnr *Container
+
+	sig *refs.Signature
+}
+type PutRequest struct {
+	body *PutRequestBody
+
+	session.RequestHeaders
+}
+
+type PutResponseBody struct {
+	cid *refs.ContainerID
+}
+
+type PutResponse struct {
+	body *PutResponseBody
+
+	session.ResponseHeaders
+}
+
+type GetRequestBody struct {
+	cid *refs.ContainerID
+}
+
+type GetRequest struct {
+	body *GetRequestBody
+
+	session.RequestHeaders
+}
+
+type GetResponseBody struct {
+	cnr *Container
+
+	token *session.Token
+
+	sig *refs.Signature
+}
+
+type GetResponse struct {
+	body *GetResponseBody
+
+	session.ResponseHeaders
+}
+
+type DeleteRequestBody struct {
+	cid *refs.ContainerID
+
+	sig *refs.Signature
+}
+
+type DeleteRequest struct {
+	body *DeleteRequestBody
+
+	session.RequestHeaders
+}
+
+type DeleteResponseBody struct{}
+
+type DeleteResponse struct {
+	body *DeleteResponseBody
+
+	session.ResponseHeaders
+}
+
+type ListRequestBody struct {
+	ownerID *refs.OwnerID
+}
+
+type ListRequest struct {
+	body *ListRequestBody
+
+	session.RequestHeaders
+}
+
+type ListResponseBody struct {
+	cidList []refs.ContainerID
+}
+
+type ListResponse struct {
+	body *ListResponseBody
+
+	session.ResponseHeaders
+}
+
+func (a *Attribute) GetKey() string {
+	if a != nil {
+		return a.key
+	}
+
+	return ""
+}
+
+func (a *Attribute) SetKey(v string) {
+	a.key = v
+}
+
+func (a *Attribute) GetValue() string {
+	if a != nil {
+		return a.val
+	}
+
+	return ""
+}
+
+func (a *Attribute) SetValue(v string) {
+	a.val = v
+}
+
+func (c *Container) GetVersion() *refs.Version {
+	if c != nil {
+		return c.version
+	}
+
+	return nil
+}
+
+func (c *Container) SetVersion(v *refs.Version) {
+	c.version = v
+}
+
+func (c *Container) GetOwnerID() *refs.OwnerID {
+	if c != nil {
+		return c.ownerID
+	}
+
+	return nil
+}
+
+func (c *Container) SetOwnerID(v *refs.OwnerID) {
+	c.ownerID = v
+}
+
+func (c *Container) GetNonce() []byte {
+	if c != nil {
+		return c.nonce
+	}
+
+	return nil
+}
+
+func (c *Container) SetNonce(v []byte) {
+	c.nonce = v
+}
+
+func (c *Container) GetBasicACL() uint32 {
+	if c != nil {
+		return c.basicACL
+	}
+
+	return 0
+}
+
+func (c *Container) SetBasicACL(v uint32) {
+	c.basicACL = v
+}
+
+func (c *Container) GetAttributes() []Attribute {
+	if c != nil {
+		return c.attr
+	}
+
+	return nil
+}
+
+func (c *Container) SetAttributes(v []Attribute) {
+	c.attr = v
+}
+
+func (c *Container) GetPlacementPolicy() *netmap.PlacementPolicy {
+	if c != nil {
+		return c.policy
+	}
+
+	return nil
+}
+
+func (c *Container) SetPlacementPolicy(v *netmap.PlacementPolicy) {
+	c.policy = v
+}
+
+func (r *PutRequestBody) GetContainer() *Container {
+	if r != nil {
+		return r.cnr
+	}
+
+	return nil
+}
+
+func (r *PutRequestBody) SetContainer(v *Container) {
+	r.cnr = v
+}
+
+func (r *PutRequestBody) GetSignature() *refs.Signature {
+	if r != nil {
+		return r.sig
+	}
+
+	return nil
+}
+
+func (r *PutRequestBody) SetSignature(v *refs.Signature) {
+	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
+	v.SetScheme(0)
+	r.sig = v
+}
+
+func (r *PutRequest) GetBody() *PutRequestBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *PutRequest) SetBody(v *PutRequestBody) {
+	r.body = v
+}
+
+func (r *PutResponseBody) GetContainerID() *refs.ContainerID {
+	if r != nil {
+		return r.cid
+	}
+
+	return nil
+}
+
+func (r *PutResponseBody) SetContainerID(v *refs.ContainerID) {
+	r.cid = v
+}
+
+func (r *PutResponse) GetBody() *PutResponseBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *PutResponse) SetBody(v *PutResponseBody) {
+	r.body = v
+}
+
+func (r *GetRequestBody) GetContainerID() *refs.ContainerID {
+	if r != nil {
+		return r.cid
+	}
+
+	return nil
+}
+
+func (r *GetRequestBody) SetContainerID(v *refs.ContainerID) {
+	r.cid = v
+}
+
+func (r *GetRequest) GetBody() *GetRequestBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *GetRequest) SetBody(v *GetRequestBody) {
+	r.body = v
+}
+
+func (r *GetResponseBody) GetContainer() *Container {
+	if r != nil {
+		return r.cnr
+	}
+
+	return nil
+}
+
+func (r *GetResponseBody) SetContainer(v *Container) {
+	r.cnr = v
+}
+
+// GetSessionToken returns token of the session within which requested
+// container was created.
+func (r *GetResponseBody) GetSessionToken() *session.Token {
+	if r != nil {
+		return r.token
+	}
+
+	return nil
+}
+
+// SetSessionToken sets token of the session within which requested
+// container was created.
+func (r *GetResponseBody) SetSessionToken(v *session.Token) {
+	r.token = v
+}
+
+// GetSignature returns signature of the requested container.
+func (r *GetResponseBody) GetSignature() *refs.Signature {
+	if r != nil {
+		return r.sig
+	}
+
+	return nil
+}
+
+// SetSignature sets signature of the requested container.
+func (r *GetResponseBody) SetSignature(v *refs.Signature) {
+	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
+	v.SetScheme(0)
+	r.sig = v
+}
+
+func (r *GetResponse) GetBody() *GetResponseBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *GetResponse) SetBody(v *GetResponseBody) {
+	r.body = v
+}
+
+func (r *DeleteRequestBody) GetContainerID() *refs.ContainerID {
+	if r != nil {
+		return r.cid
+	}
+
+	return nil
+}
+
+func (r *DeleteRequestBody) SetContainerID(v *refs.ContainerID) {
+	r.cid = v
+}
+
+func (r *DeleteRequestBody) GetSignature() *refs.Signature {
+	if r != nil {
+		return r.sig
+	}
+
+	return nil
+}
+
+func (r *DeleteRequestBody) SetSignature(v *refs.Signature) {
+	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
+	v.SetScheme(0)
+	r.sig = v
+}
+
+func (r *DeleteRequest) GetBody() *DeleteRequestBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *DeleteRequest) SetBody(v *DeleteRequestBody) {
+	r.body = v
+}
+
+func (r *DeleteResponse) GetBody() *DeleteResponseBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *DeleteResponse) SetBody(v *DeleteResponseBody) {
+	r.body = v
+}
+
+func (r *ListRequestBody) GetOwnerID() *refs.OwnerID {
+	if r != nil {
+		return r.ownerID
+	}
+
+	return nil
+}
+
+func (r *ListRequestBody) SetOwnerID(v *refs.OwnerID) {
+	r.ownerID = v
+}
+
+func (r *ListRequest) GetBody() *ListRequestBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *ListRequest) SetBody(v *ListRequestBody) {
+	r.body = v
+}
+
+func (r *ListResponseBody) GetContainerIDs() []refs.ContainerID {
+	if r != nil {
+		return r.cidList
+	}
+
+	return nil
+}
+
+func (r *ListResponseBody) SetContainerIDs(v []refs.ContainerID) {
+	r.cidList = v
+}
+
+func (r *ListResponse) GetBody() *ListResponseBody {
+	if r != nil {
+		return r.body
+	}
+
+	return nil
+}
+
+func (r *ListResponse) SetBody(v *ListResponseBody) {
+	r.body = v
+}

api/lock/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,26 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package lock
+
+func DoFuzzProtoLock(data []byte) int {
+	msg := new(Lock)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONLock(data []byte) int {
+	msg := new(Lock)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/lock/grpc/types_frostfs_test.go

@@ -0,0 +1,21 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package lock
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoLock(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoLock(data)
+	})
+}
+func FuzzJSONLock(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONLock(data)
+	})
+}

api/netmap/convert.go

@@ -0,0 +1,916 @@
+package netmap
+
+import (
+	netmap "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs"
+	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/refs/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (f *Filter) ToGRPCMessage() grpc.Message {
+	var m *netmap.Filter
+
+	if f != nil {
+		m = new(netmap.Filter)
+
+		m.SetKey(f.key)
+		m.SetValue(f.value)
+		m.SetName(f.name)
+		m.SetOp(OperationToGRPCMessage(f.op))
+		m.SetFilters(FiltersToGRPC(f.filters))
+	}
+
+	return m
+}
+
+func (f *Filter) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.Filter)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	f.filters, err = FiltersFromGRPC(v.GetFilters())
+	if err != nil {
+		return err
+	}
+
+	f.key = v.GetKey()
+	f.value = v.GetValue()
+	f.name = v.GetName()
+	f.op = OperationFromGRPCMessage(v.GetOp())
+
+	return nil
+}
+
+func FiltersToGRPC(fs []Filter) (res []netmap.Filter) {
+	if fs != nil {
+		res = make([]netmap.Filter, 0, len(fs))
+
+		for i := range fs {
+			res = append(res, *fs[i].ToGRPCMessage().(*netmap.Filter))
+		}
+	}
+
+	return
+}
+
+func FiltersFromGRPC(fs []netmap.Filter) (res []Filter, err error) {
+	if fs != nil {
+		res = make([]Filter, len(fs))
+
+		for i := range fs {
+			err = res[i].FromGRPCMessage(&fs[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (s *Selector) ToGRPCMessage() grpc.Message {
+	var m *netmap.Selector
+
+	if s != nil {
+		m = new(netmap.Selector)
+
+		m.SetName(s.name)
+		m.SetAttribute(s.attribute)
+		m.SetFilter(s.filter)
+		m.SetCount(s.count)
+		m.SetClause(ClauseToGRPCMessage(s.clause))
+	}
+
+	return m
+}
+
+func (s *Selector) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.Selector)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	s.name = v.GetName()
+	s.attribute = v.GetAttribute()
+	s.filter = v.GetFilter()
+	s.count = v.GetCount()
+	s.clause = ClauseFromGRPCMessage(v.GetClause())
+
+	return nil
+}
+
+func SelectorsToGRPC(ss []Selector) (res []netmap.Selector) {
+	if ss != nil {
+		res = make([]netmap.Selector, 0, len(ss))
+
+		for i := range ss {
+			res = append(res, *ss[i].ToGRPCMessage().(*netmap.Selector))
+		}
+	}
+
+	return
+}
+
+func SelectorsFromGRPC(ss []netmap.Selector) (res []Selector, err error) {
+	if ss != nil {
+		res = make([]Selector, len(ss))
+
+		for i := range ss {
+			err = res[i].FromGRPCMessage(&ss[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (r *Replica) ToGRPCMessage() grpc.Message {
+	var m *netmap.Replica
+
+	if r != nil {
+		m = new(netmap.Replica)
+
+		m.SetSelector(r.selector)
+		m.SetCount(r.count)
+		m.EcDataCount = r.ecDataCount
+		m.EcParityCount = r.ecParityCount
+	}
+
+	return m
+}
+
+func (r *Replica) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.Replica)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	r.selector = v.GetSelector()
+	r.count = v.GetCount()
+	r.ecDataCount = v.GetEcDataCount()
+	r.ecParityCount = v.GetEcParityCount()
+
+	return nil
+}
+
+func ReplicasToGRPC(rs []Replica) (res []netmap.Replica) {
+	if rs != nil {
+		res = make([]netmap.Replica, 0, len(rs))
+
+		for i := range rs {
+			res = append(res, *rs[i].ToGRPCMessage().(*netmap.Replica))
+		}
+	}
+
+	return
+}
+
+func ReplicasFromGRPC(rs []netmap.Replica) (res []Replica, err error) {
+	if rs != nil {
+		res = make([]Replica, len(rs))
+
+		for i := range rs {
+			err = res[i].FromGRPCMessage(&rs[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (p *PlacementPolicy) ToGRPCMessage() grpc.Message {
+	var m *netmap.PlacementPolicy
+
+	if p != nil {
+		m = new(netmap.PlacementPolicy)
+
+		m.SetFilters(FiltersToGRPC(p.filters))
+		m.SetSelectors(SelectorsToGRPC(p.selectors))
+		m.SetReplicas(ReplicasToGRPC(p.replicas))
+		m.SetContainerBackupFactor(p.backupFactor)
+		m.SetUnique(p.unique)
+	}
+
+	return m
+}
+
+func (p *PlacementPolicy) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.PlacementPolicy)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	p.filters, err = FiltersFromGRPC(v.GetFilters())
+	if err != nil {
+		return err
+	}
+
+	p.selectors, err = SelectorsFromGRPC(v.GetSelectors())
+	if err != nil {
+		return err
+	}
+
+	p.replicas, err = ReplicasFromGRPC(v.GetReplicas())
+	if err != nil {
+		return err
+	}
+
+	p.backupFactor = v.GetContainerBackupFactor()
+
+	p.unique = v.GetUnique()
+
+	return nil
+}
+
+func ClauseToGRPCMessage(n Clause) netmap.Clause {
+	return netmap.Clause(n)
+}
+
+func ClauseFromGRPCMessage(n netmap.Clause) Clause {
+	return Clause(n)
+}
+
+func OperationToGRPCMessage(n Operation) netmap.Operation {
+	return netmap.Operation(n)
+}
+
+func OperationFromGRPCMessage(n netmap.Operation) Operation {
+	return Operation(n)
+}
+
+func NodeStateToGRPCMessage(n NodeState) netmap.NodeInfo_State {
+	return netmap.NodeInfo_State(n)
+}
+
+func NodeStateFromRPCMessage(n netmap.NodeInfo_State) NodeState {
+	return NodeState(n)
+}
+
+func (a *Attribute) ToGRPCMessage() grpc.Message {
+	var m *netmap.NodeInfo_Attribute
+
+	if a != nil {
+		m = new(netmap.NodeInfo_Attribute)
+
+		m.SetKey(a.key)
+		m.SetValue(a.value)
+		m.SetParents(a.parents)
+	}
+
+	return m
+}
+
+func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NodeInfo_Attribute)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	a.key = v.GetKey()
+	a.value = v.GetValue()
+	a.parents = v.GetParents()
+
+	return nil
+}
+
+func AttributesToGRPC(as []Attribute) (res []netmap.NodeInfo_Attribute) {
+	if as != nil {
+		res = make([]netmap.NodeInfo_Attribute, 0, len(as))
+
+		for i := range as {
+			res = append(res, *as[i].ToGRPCMessage().(*netmap.NodeInfo_Attribute))
+		}
+	}
+
+	return
+}
+
+func AttributesFromGRPC(as []netmap.NodeInfo_Attribute) (res []Attribute, err error) {
+	if as != nil {
+		res = make([]Attribute, len(as))
+
+		for i := range as {
+			err = res[i].FromGRPCMessage(&as[i])
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+func (ni *NodeInfo) ToGRPCMessage() grpc.Message {
+	var m *netmap.NodeInfo
+
+	if ni != nil {
+		m = new(netmap.NodeInfo)
+
+		m.SetPublicKey(ni.publicKey)
+		m.SetAddresses(ni.addresses)
+		m.SetState(NodeStateToGRPCMessage(ni.state))
+		m.SetAttributes(AttributesToGRPC(ni.attributes))
+	}
+
+	return m
+}
+
+func (ni *NodeInfo) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NodeInfo)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	ni.attributes, err = AttributesFromGRPC(v.GetAttributes())
+	if err != nil {
+		return err
+	}
+
+	ni.publicKey = v.GetPublicKey()
+	ni.addresses = v.GetAddresses()
+	ni.state = NodeStateFromRPCMessage(v.GetState())
+
+	return nil
+}
+
+func (l *LocalNodeInfoRequestBody) ToGRPCMessage() grpc.Message {
+	var m *netmap.LocalNodeInfoRequest_Body
+
+	if l != nil {
+		m = new(netmap.LocalNodeInfoRequest_Body)
+	}
+
+	return m
+}
+
+func (l *LocalNodeInfoRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.LocalNodeInfoRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	return nil
+}
+
+func (l *LocalNodeInfoRequest) ToGRPCMessage() grpc.Message {
+	var m *netmap.LocalNodeInfoRequest
+
+	if l != nil {
+		m = new(netmap.LocalNodeInfoRequest)
+
+		m.SetBody(l.body.ToGRPCMessage().(*netmap.LocalNodeInfoRequest_Body))
+		l.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (l *LocalNodeInfoRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.LocalNodeInfoRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		l.body = nil
+	} else {
+		if l.body == nil {
+			l.body = new(LocalNodeInfoRequestBody)
+		}
+
+		err = l.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return l.RequestHeaders.FromMessage(v)
+}
+
+func (l *LocalNodeInfoResponseBody) ToGRPCMessage() grpc.Message {
+	var m *netmap.LocalNodeInfoResponse_Body
+
+	if l != nil {
+		m = new(netmap.LocalNodeInfoResponse_Body)
+
+		m.SetVersion(l.version.ToGRPCMessage().(*refsGRPC.Version))
+		m.SetNodeInfo(l.nodeInfo.ToGRPCMessage().(*netmap.NodeInfo))
+	}
+
+	return m
+}
+
+func (l *LocalNodeInfoResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.LocalNodeInfoResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	version := v.GetVersion()
+	if version == nil {
+		l.version = nil
+	} else {
+		if l.version == nil {
+			l.version = new(refs.Version)
+		}
+
+		err = l.version.FromGRPCMessage(version)
+		if err != nil {
+			return err
+		}
+	}
+
+	nodeInfo := v.GetNodeInfo()
+	if nodeInfo == nil {
+		l.nodeInfo = nil
+	} else {
+		if l.nodeInfo == nil {
+			l.nodeInfo = new(NodeInfo)
+		}
+
+		err = l.nodeInfo.FromGRPCMessage(nodeInfo)
+	}
+
+	return err
+}
+
+func (l *LocalNodeInfoResponse) ToGRPCMessage() grpc.Message {
+	var m *netmap.LocalNodeInfoResponse
+
+	if l != nil {
+		m = new(netmap.LocalNodeInfoResponse)
+
+		m.SetBody(l.body.ToGRPCMessage().(*netmap.LocalNodeInfoResponse_Body))
+		l.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (l *LocalNodeInfoResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.LocalNodeInfoResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		l.body = nil
+	} else {
+		if l.body == nil {
+			l.body = new(LocalNodeInfoResponseBody)
+		}
+
+		err = l.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return l.ResponseHeaders.FromMessage(v)
+}
+
+func (x *NetworkParameter) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetworkConfig_Parameter
+
+	if x != nil {
+		m = new(netmap.NetworkConfig_Parameter)
+
+		m.SetKey(x.k)
+		m.SetValue(x.v)
+	}
+
+	return m
+}
+
+func (x *NetworkParameter) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetworkConfig_Parameter)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	x.k = v.GetKey()
+	x.v = v.GetValue()
+
+	return nil
+}
+
+func (x *NetworkConfig) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetworkConfig
+
+	if x != nil {
+		m = new(netmap.NetworkConfig)
+
+		var ps []netmap.NetworkConfig_Parameter
+
+		if ln := len(x.ps); ln > 0 {
+			ps = make([]netmap.NetworkConfig_Parameter, 0, ln)
+
+			for i := range ln {
+				ps = append(ps, *x.ps[i].ToGRPCMessage().(*netmap.NetworkConfig_Parameter))
+			}
+		}
+
+		m.SetParameters(ps)
+	}
+
+	return m
+}
+
+func (x *NetworkConfig) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetworkConfig)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var (
+		ps   []NetworkParameter
+		psV2 = v.GetParameters()
+	)
+
+	if psV2 != nil {
+		ln := len(psV2)
+
+		ps = make([]NetworkParameter, ln)
+
+		for i := range ln {
+			if err := ps[i].FromGRPCMessage(&psV2[i]); err != nil {
+				return err
+			}
+		}
+	}
+
+	x.ps = ps
+
+	return nil
+}
+
+func (i *NetworkInfo) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetworkInfo
+
+	if i != nil {
+		m = new(netmap.NetworkInfo)
+
+		m.SetMagicNumber(i.magicNum)
+		m.SetCurrentEpoch(i.curEpoch)
+		m.SetMsPerBlock(i.msPerBlock)
+		m.SetNetworkConfig(i.netCfg.ToGRPCMessage().(*netmap.NetworkConfig))
+	}
+
+	return m
+}
+
+func (i *NetworkInfo) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetworkInfo)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	netCfg := v.GetNetworkConfig()
+	if netCfg == nil {
+		i.netCfg = nil
+	} else {
+		if i.netCfg == nil {
+			i.netCfg = new(NetworkConfig)
+		}
+
+		err = i.netCfg.FromGRPCMessage(netCfg)
+		if err != nil {
+			return err
+		}
+	}
+
+	i.magicNum = v.GetMagicNumber()
+	i.curEpoch = v.GetCurrentEpoch()
+	i.msPerBlock = v.GetMsPerBlock()
+
+	return nil
+}
+
+func (l *NetworkInfoRequestBody) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetworkInfoRequest_Body
+
+	if l != nil {
+		m = new(netmap.NetworkInfoRequest_Body)
+	}
+
+	return m
+}
+
+func (l *NetworkInfoRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetworkInfoRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	return nil
+}
+
+func (l *NetworkInfoRequest) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetworkInfoRequest
+
+	if l != nil {
+		m = new(netmap.NetworkInfoRequest)
+
+		m.SetBody(l.body.ToGRPCMessage().(*netmap.NetworkInfoRequest_Body))
+		l.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (l *NetworkInfoRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetworkInfoRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		l.body = nil
+	} else {
+		if l.body == nil {
+			l.body = new(NetworkInfoRequestBody)
+		}
+
+		err = l.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return l.RequestHeaders.FromMessage(v)
+}
+
+func (i *NetworkInfoResponseBody) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetworkInfoResponse_Body
+
+	if i != nil {
+		m = new(netmap.NetworkInfoResponse_Body)
+
+		m.SetNetworkInfo(i.netInfo.ToGRPCMessage().(*netmap.NetworkInfo))
+	}
+
+	return m
+}
+
+func (i *NetworkInfoResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetworkInfoResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	netInfo := v.GetNetworkInfo()
+	if netInfo == nil {
+		i.netInfo = nil
+	} else {
+		if i.netInfo == nil {
+			i.netInfo = new(NetworkInfo)
+		}
+
+		err = i.netInfo.FromGRPCMessage(netInfo)
+	}
+
+	return err
+}
+
+func (l *NetworkInfoResponse) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetworkInfoResponse
+
+	if l != nil {
+		m = new(netmap.NetworkInfoResponse)
+
+		m.SetBody(l.body.ToGRPCMessage().(*netmap.NetworkInfoResponse_Body))
+		l.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (l *NetworkInfoResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetworkInfoResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		l.body = nil
+	} else {
+		if l.body == nil {
+			l.body = new(NetworkInfoResponseBody)
+		}
+
+		err = l.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return l.ResponseHeaders.FromMessage(v)
+}
+
+func (x *NetMap) ToGRPCMessage() grpc.Message {
+	var m *netmap.Netmap
+
+	if x != nil {
+		m = new(netmap.Netmap)
+
+		m.SetEpoch(x.epoch)
+
+		if x.nodes != nil {
+			nodes := make([]netmap.NodeInfo, len(x.nodes))
+
+			for i := range x.nodes {
+				nodes[i] = *x.nodes[i].ToGRPCMessage().(*netmap.NodeInfo)
+			}
+
+			m.SetNodes(nodes)
+		}
+	}
+
+	return m
+}
+
+func (x *NetMap) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.Netmap)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	nodes := v.GetNodes()
+	if nodes == nil {
+		x.nodes = nil
+	} else {
+		x.nodes = make([]NodeInfo, len(nodes))
+
+		for i := range nodes {
+			err = x.nodes[i].FromGRPCMessage(&nodes[i])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	x.epoch = v.GetEpoch()
+
+	return nil
+}
+
+func (x *SnapshotRequestBody) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetmapSnapshotRequest_Body
+
+	if x != nil {
+		m = new(netmap.NetmapSnapshotRequest_Body)
+	}
+
+	return m
+}
+
+func (x *SnapshotRequestBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetmapSnapshotRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	return nil
+}
+
+func (x *SnapshotRequest) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetmapSnapshotRequest
+
+	if x != nil {
+		m = new(netmap.NetmapSnapshotRequest)
+
+		m.SetBody(x.body.ToGRPCMessage().(*netmap.NetmapSnapshotRequest_Body))
+		x.RequestHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (x *SnapshotRequest) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetmapSnapshotRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		x.body = nil
+	} else {
+		if x.body == nil {
+			x.body = new(SnapshotRequestBody)
+		}
+
+		err = x.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return x.RequestHeaders.FromMessage(v)
+}
+
+func (x *SnapshotResponseBody) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetmapSnapshotResponse_Body
+
+	if x != nil {
+		m = new(netmap.NetmapSnapshotResponse_Body)
+
+		m.SetNetmap(x.netMap.ToGRPCMessage().(*netmap.Netmap))
+	}
+
+	return m
+}
+
+func (x *SnapshotResponseBody) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetmapSnapshotResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	netMap := v.GetNetmap()
+	if netMap == nil {
+		x.netMap = nil
+	} else {
+		if x.netMap == nil {
+			x.netMap = new(NetMap)
+		}
+
+		err = x.netMap.FromGRPCMessage(netMap)
+	}
+
+	return err
+}
+
+func (x *SnapshotResponse) ToGRPCMessage() grpc.Message {
+	var m *netmap.NetmapSnapshotResponse
+
+	if x != nil {
+		m = new(netmap.NetmapSnapshotResponse)
+
+		m.SetBody(x.body.ToGRPCMessage().(*netmap.NetmapSnapshotResponse_Body))
+		x.ResponseHeaders.ToMessage(m)
+	}
+
+	return m
+}
+
+func (x *SnapshotResponse) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*netmap.NetmapSnapshotResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	body := v.GetBody()
+	if body == nil {
+		x.body = nil
+	} else {
+		if x.body == nil {
+			x.body = new(SnapshotResponseBody)
+		}
+
+		err = x.body.FromGRPCMessage(body)
+		if err != nil {
+			return err
+		}
+	}
+
+	return x.ResponseHeaders.FromMessage(v)
+}

api/netmap/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,121 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+func DoFuzzProtoLocalNodeInfoRequest(data []byte) int {
+	msg := new(LocalNodeInfoRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONLocalNodeInfoRequest(data []byte) int {
+	msg := new(LocalNodeInfoRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoLocalNodeInfoResponse(data []byte) int {
+	msg := new(LocalNodeInfoResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONLocalNodeInfoResponse(data []byte) int {
+	msg := new(LocalNodeInfoResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkInfoRequest(data []byte) int {
+	msg := new(NetworkInfoRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkInfoRequest(data []byte) int {
+	msg := new(NetworkInfoRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkInfoResponse(data []byte) int {
+	msg := new(NetworkInfoResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkInfoResponse(data []byte) int {
+	msg := new(NetworkInfoResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetmapSnapshotRequest(data []byte) int {
+	msg := new(NetmapSnapshotRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetmapSnapshotRequest(data []byte) int {
+	msg := new(NetmapSnapshotRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetmapSnapshotResponse(data []byte) int {
+	msg := new(NetmapSnapshotResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetmapSnapshotResponse(data []byte) int {
+	msg := new(NetmapSnapshotResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/netmap/grpc/service_frostfs_test.go

@@ -0,0 +1,71 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoLocalNodeInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoLocalNodeInfoRequest(data)
+	})
+}
+func FuzzJSONLocalNodeInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONLocalNodeInfoRequest(data)
+	})
+}
+func FuzzProtoLocalNodeInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoLocalNodeInfoResponse(data)
+	})
+}
+func FuzzJSONLocalNodeInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONLocalNodeInfoResponse(data)
+	})
+}
+func FuzzProtoNetworkInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkInfoRequest(data)
+	})
+}
+func FuzzJSONNetworkInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkInfoRequest(data)
+	})
+}
+func FuzzProtoNetworkInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkInfoResponse(data)
+	})
+}
+func FuzzJSONNetworkInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkInfoResponse(data)
+	})
+}
+func FuzzProtoNetmapSnapshotRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetmapSnapshotRequest(data)
+	})
+}
+func FuzzJSONNetmapSnapshotRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetmapSnapshotRequest(data)
+	})
+}
+func FuzzProtoNetmapSnapshotResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetmapSnapshotResponse(data)
+	})
+}
+func FuzzJSONNetmapSnapshotResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetmapSnapshotResponse(data)
+	})
+}

api/netmap/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,159 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+func DoFuzzProtoFilter(data []byte) int {
+	msg := new(Filter)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONFilter(data []byte) int {
+	msg := new(Filter)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoSelector(data []byte) int {
+	msg := new(Selector)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONSelector(data []byte) int {
+	msg := new(Selector)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoReplica(data []byte) int {
+	msg := new(Replica)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONReplica(data []byte) int {
+	msg := new(Replica)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoPlacementPolicy(data []byte) int {
+	msg := new(PlacementPolicy)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONPlacementPolicy(data []byte) int {
+	msg := new(PlacementPolicy)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNodeInfo(data []byte) int {
+	msg := new(NodeInfo)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNodeInfo(data []byte) int {
+	msg := new(NodeInfo)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetmap(data []byte) int {
+	msg := new(Netmap)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetmap(data []byte) int {
+	msg := new(Netmap)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkConfig(data []byte) int {
+	msg := new(NetworkConfig)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkConfig(data []byte) int {
+	msg := new(NetworkConfig)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkInfo(data []byte) int {
+	msg := new(NetworkInfo)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkInfo(data []byte) int {
+	msg := new(NetworkInfo)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

api/netmap/grpc/types_frostfs_test.go

@@ -0,0 +1,91 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoFilter(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoFilter(data)
+	})
+}
+func FuzzJSONFilter(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONFilter(data)
+	})
+}
+func FuzzProtoSelector(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoSelector(data)
+	})
+}
+func FuzzJSONSelector(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONSelector(data)
+	})
+}
+func FuzzProtoReplica(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoReplica(data)
+	})
+}
+func FuzzJSONReplica(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONReplica(data)
+	})
+}
+func FuzzProtoPlacementPolicy(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoPlacementPolicy(data)
+	})
+}
+func FuzzJSONPlacementPolicy(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONPlacementPolicy(data)
+	})
+}
+func FuzzProtoNodeInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNodeInfo(data)
+	})
+}
+func FuzzJSONNodeInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNodeInfo(data)
+	})
+}
+func FuzzProtoNetmap(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetmap(data)
+	})
+}
+func FuzzJSONNetmap(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetmap(data)
+	})
+}
+func FuzzProtoNetworkConfig(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkConfig(data)
+	})
+}
+func FuzzJSONNetworkConfig(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkConfig(data)
+	})
+}
+func FuzzProtoNetworkInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkInfo(data)
+	})
+}
+func FuzzJSONNetworkInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkInfo(data)
+	})
+}

api/netmap/json.go

@@ -0,0 +1,62 @@
+package netmap
+
+import (
+	netmap "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/message"
+)
+
+func (p *PlacementPolicy) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(p)
+}
+
+func (p *PlacementPolicy) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(p, data, new(netmap.PlacementPolicy))
+}
+
+func (f *Filter) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(f)
+}
+
+func (f *Filter) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(f, data, new(netmap.Filter))
+}
+
+func (s *Selector) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(s)
+}
+
+func (s *Selector) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(s, data, new(netmap.Selector))
+}
+
+func (r *Replica) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(r)
+}
+
+func (r *Replica) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(r, data, new(netmap.Replica))
+}
+
+func (a *Attribute) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(a)
+}
+
+func (a *Attribute) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(a, data, new(netmap.NodeInfo_Attribute))
+}
+
+func (ni *NodeInfo) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(ni)
+}
+
+func (ni *NodeInfo) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(ni, data, new(netmap.NodeInfo))
+}
+
+func (i *NetworkInfo) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(i)
+}
+
+func (i *NetworkInfo) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(i, data, new(netmap.NetworkInfo))
+}