[#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/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,45 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: community, triage, bug
+assignees: ''
+
+---
+
+<!--- Provide a general summary of the issue in the Title above -->
+
+## Expected Behavior
+<!--- If you're describing a bug, tell us what should happen -->
+<!--- If you're suggesting a change/improvement, tell us how it should work -->
+
+## Current Behavior
+<!--- If describing a bug, tell us what happens instead of the expected behavior -->
+<!--- If suggesting a change/improvement, explain the difference from current behavior -->
+
+## Possible Solution
+<!--- Not obligatory -->
+<!--- If no reason/fix/additions for the bug can be suggested, -->
+<!--- uncomment the following phrase: -->
+
+<!--- No fix can be suggested by a QA engineer. Further solutions shall be up to developers. -->
+
+## Steps to Reproduce (for bugs)
+<!--- Provide a link to a live example, or an unambiguous set of steps to -->
+<!--- reproduce this bug. -->
+
+1.
+
+## Context
+<!--- How has this issue affected you? What are you trying to accomplish? -->
+<!--- Providing context helps us come up with a solution that is most useful in the real world -->
+
+## Regression
+<!-- Is this issue a regression? (Yes / No) -->
+<!-- If Yes, optionally please include version or commit id or PR# that caused this regression, if you have these details. -->
+
+## Your Environment
+<!--- Include as many relevant details about the environment you experienced the bug in -->
+* Version used:
+* Server setup and configuration:
+* Operating System and version (`uname -a`):

.forgejo/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.forgejo/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: community, triage
+assignees: ''
+
+---
+
+## Is your feature request related to a problem? Please describe.
+<!--- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
+
+## Describe the solution you'd like
+<!--- A clear and concise description of what you want to happen. -->
+
+## Describe alternatives you've considered
+<!--- A clear and concise description of any alternative solutions or features you've considered. -->
+
+## Additional context
+<!--- Add any other context or screenshots about the feature request here. -->

.forgejo/workflows/dco.yml

@@ -0,0 +1,21 @@
+name: DCO
+on: [pull_request]
+
+jobs:
+  dco:
+    name: DCO
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.23'
+
+      - name: Run commit format checker
+        uses: https://git.frostfs.info/TrueCloudLab/dco-go@v3
+        with:
+          from: 'origin/${{ github.event.pull_request.base.ref }}'

.forgejo/workflows/tests.yml

@@ -0,0 +1,39 @@
+name: Tests and linters
+on: [pull_request]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          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.22', '1.23' ]
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '${{ matrix.go_versions }}'
+
+      - name: Run tests
+        run: make test

.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/workflows/dco.yml

@@ -1,21 +0,0 @@
-name: DCO check
-
-on:
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  commits_check_job:
-    runs-on: ubuntu-latest
-    name: Commits Check
-    steps:
-    - name: Get PR Commits
-      id: 'get-pr-commits'
-      uses: tim-actions/get-pr-commits@master
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-    - name: DCO Check
-      uses: tim-actions/dco@master
-      with:
-        commits: ${{ steps.get-pr-commits.outputs.commits }}

.github/workflows/tests.yml

@@ -1,52 +0,0 @@
-name: neofs-sdk-go tests
-
-on:
-  pull_request:
-    branches:
-      - master
-    types: [opened, synchronize]
-    paths-ignore:
-      - '**/*.md'
-  workflow_dispatch:
-
-jobs:
-  tests:
-    name: Tests
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        go_versions: [ '1.16.x', '1.17.x' ]
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '${{ matrix.go_versions }}'
-
-      - name: Restore Go modules from cache
-        uses: actions/cache@v2
-        with:
-          path: /home/runner/go/pkg/mod
-          key: deps-${{ hashFiles('go.sum') }}
-
-      - name: Update Go modules
-        run: make dep
-
-      - name: Run tests
-        run: make test
-
-  lint:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-
-      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
-        with:
-          version: latest
-          only-new-issues: true

.gitignore

@@ -21,3 +21,13 @@ vendor/
 # coverage
 coverage.txt
 coverage.html
+
+# antlr tool jar
+antlr*.jar
+
+# tempfiles
+.cache
+
+# binary
+bin/
+release/

.golangci.yml

@@ -4,15 +4,16 @@
 # options for analysis running
 run:
   # timeout for analysis, e.g. 30s, 5m, default is 1m
-  timeout: 5m
+  timeout: 10m
 
   # include test files or not, default is true
-  tests: true
+  tests: false
 
 # 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:
@@ -24,6 +25,13 @@ linters-settings:
   govet:
     # report about shadowed variables
     check-shadowing: false
+  staticcheck:
+    checks: ["all"]
+  funlen:
+    lines: 80 # default 60
+    statements: 60 # default 40
+  gocognit:
+    min-complexity: 40 # default 30
 
 linters:
   enable:
@@ -32,28 +40,30 @@ linters:
     - revive
 
     # some default golangci-lint linters
-    - deadcode
     - errcheck
     - gosimple
+    - godot
     - ineffassign
     - staticcheck
-    - structcheck
     - typecheck
     - unused
-    - varcheck
 
     # extra linters
+    - bidichk
+    - durationcheck
     - exhaustive
-    - godot
+    - copyloopvar
     - gofmt
-    - whitespace
     - goimports
+    - misspell
+    - predeclared
+    - reassign
+    - whitespace
+    - containedctx
+    - funlen
+    - gocognit
+    - contextcheck
+    - protogetter
+    - intrange
   disable-all: true
   fast: false
-
-issues:
-  include:
-    - EXC0002 # should have a comment
-    - EXC0003 # test/Test ... consider calling this
-    - EXC0004 # govet
-    - EXC0005 # C-style breaks

.pre-commit-config.yaml

@@ -0,0 +1,36 @@
+ci:
+  autofix_prs: false
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+    - id: check-added-large-files
+    - id: check-case-conflict
+    - id: check-executables-have-shebangs
+    - id: check-shebang-scripts-are-executable
+    - id: check-merge-conflict
+    - id: check-json
+    - id: check-xml
+    - id: check-yaml
+    - id: trailing-whitespace
+      args: [--markdown-linebreak-ext=md]
+    - id: end-of-file-fixer
+      exclude: "(.key|.interp|.tokens)$"
+
+  - repo: local
+    hooks:
+       - id: go-unit-tests
+         name: go unit tests
+         entry: make test GOFLAGS=''
+         pass_filenames: false
+         types: [go]
+         language: system
+
+  - repo: local
+    hooks:
+      - 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

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

Makefile

@@ -1,8 +1,81 @@
 #!/usr/bin/make -f
 
+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:
@@ -13,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:
@@ -29,6 +116,24 @@ format:
 	@echo "⇒ Processing goimports check"
 	@goimports -w ./
 
+policy:
+	@wget -q https://www.antlr.org/download/antlr-${ANTLR_VERSION}-complete.jar -O antlr4-tool.jar
+	@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/%:
+	@docker build -t truecloudlab/frostfs-sdk-go --platform linux/amd64 . > /dev/null
+	@docker run --rm -t \
+	-v `pwd`:/work \
+	-u "$$(id -u):$$(id -g)" \
+	--env HOME=/work \
+	truecloudlab/frostfs-sdk-go make $*
+
+# Synchronize tree service
+sync-tree:
+	@./syncTree.sh
+
 # Show this help prompt
 help:
 	@echo '  Usage:'
@@ -38,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

@@ -1,6 +1,6 @@
-# neofs-sdk-go
+# frostfs-sdk-go
-Go implementation of NeoFS SDK. It contains high-level version-independent wrappers
+Go implementation of FrostFS SDK. It contains high-level version-independent wrappers
-for structures from [neofs-api-go](https://github.com/nspcc-dev/neofs-api-go) as well as
+for structures from [frostfs-api-go](https://git.frostfs.info/TrueCloudLab/frostfs-api-go) as well as
 helper functions for simplifying node/dApp implementations.
 
 ## Repository structure
@@ -10,63 +10,73 @@ Contains fixed-point `Decimal` type for performing balance calculations.
 
 ### eacl
 Contains Extended ACL types for fine-grained access control.
-There is also a reference implementation of checking algorithm which is used in NeoFS node.
+There is also a reference implementation of checking algorithm which is used in FrostFS node.
 
 ### checksum
 Contains `Checksum` type encapsulating checksum as well as it's kind.
-Currently Sha256 and [Tillich-Zemor hashsum](https://github.com/nspcc-dev/tzhash) are in use.
+Currently Sha256 and [Tillich-Zemor hashsum](https://git.frostfs.info/TrueCloudLab/tzhash) are in use.
 
 ### owner
-`owner.ID` type represents single account interacting with NeoFS. In v2 version of protocol
+`owner.ID` type represents single account interacting with FrostFS. In v2 version of protocol
 it is just raw bytes behing [base58-encoded address](https://docs.neo.org/docs/en-us/basic/concept/wallets.html#address)
 in Neo blockchain. Note that for historical reasons it contains
 version prefix and checksum in addition to script-hash.
 
 ### token
-Contains Bearer token type with several NeoFS-specific methods.
+Contains Bearer token type with several FrostFS-specific methods.
 
-### resolver
+### ns
-In NeoFS there are 2 types of name resolution: DNS and NNS. NNS stands for Neo Name Service
+In FrostFS there are 2 types of name resolution: DNS and NNS. NNS stands for Neo Name Service
-is just a [contract](https://github.com/nspcc-dev/neofs-contract/) deployed on a Neo blockchain.
+is just a [contract](https://git.frostfs.info/TrueCloudLab/frostfs-contract) deployed on a Neo blockchain.
 Basically, NNS is just a DNS-on-chain which can be used for resolving container nice-names as well
 as any other name in dApps. See our [CoreDNS plugin](https://github.com/nspcc-dev/coredns/tree/master/plugin/nns)
 for the example of how NNS can be integrated in DNS.
 
 ### session
-To help lightweight clients interact with NeoFS without sacrificing trust, NeoFS has a concept
+To help lightweight clients interact with FrostFS without sacrificing trust, FrostFS has a concept
 of session token. It is signed by client and allows any node with which a session is established
 to perform certain actions on behalf of the user.
 
 ### client
-Contains client for working with NeoFS.
+Contains client for working with FrostFS.
 ```go
-c, _ := client.New(
+var prmInit client.PrmInit
-    client.WithAddress("localhost:40005"), // endpoint address
+prmInit.SetDefaultPrivateKey(key) // private key for request signing
-    client.WithDefaultPrivateKey(key),     // private key for request signing
-    client.WithNeoFSErrorHandling(),       // enable erroneous status parsing
-    client.WithTLSConfig(&tls.Config{}))   // custom TLS configuration
 
-ctx, cancel := context.WithTimeout(context.Background(), 5 * time.Second)
+var c client.Client
-defer cancel()
+c.Init(prmInit)
 
-res, err := c.BalanceGet(ctx, owner)
+var prmDial client.PrmDial
+prmDial.SetServerURI("grpcs://localhost:40005") // endpoint address
+
+err := c.Dial(prmDial)
 if err != nil {
     return
 }
 
-fmt.Printf("Balance for %s: %s\n", owner, res.Amount())
+ctx, cancel := context.WithTimeout(context.Background(), 5 * time.Second)
+defer cancel()
+
+var prm client.PrmBalanceGet
+prm.SetAccount(acc)
+
+res, err := c.BalanceGet(ctx, prm)
+if err != nil {
+    return
+}
+
+fmt.Printf("Balance for %s: %v\n", acc, res.Amount())
 ```
 
 #### Response status
-In NeoFS every operation can fail on multiple levels, so a single `error` doesn't suffice,
+In FrostFS every operation can fail on multiple levels, so a single `error` doesn't suffice,
 e.g. consider a case when object was put on 4 out of 5 replicas. Thus, all request execution
 details are contained in `Status` returned from every RPC call. dApp can inspect them
 if needed and perform any desired action. In the case above we may want to report
 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
-[NeoFS API](https://github.com/nspcc-dev/neofs-api/blob/master/status/types.proto). There is also
+[FrostFS API](https://git.frostfs.info/TrueCloudLab/frostfs-api/src/branch/master/status/types.proto).
-a `client.WithNeoFSErrorHandling()` to seamlessly convert erroneous statuses into Go error type.
 
 ### policy
 Contains helpers allowing conversion of placing policy from/to JSON representation
@@ -90,12 +100,12 @@ outdated in some details.
 
 ```go
 import (
-    "github.com/nspcc-dev/neofs-sdk-go/netmap"
+    "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
-    "github.com/nspcc-dev/neofs-sdk-go/object"
+    "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
 )
 
-func placementNodes(addr *object.Address, p *netmap.PlacementPolicy, neofsNodes []netmap.NodeInfo) {
+func placementNodes(addr *object.Address, p *netmap.PlacementPolicy, frostfsNodes []netmap.NodeInfo) {
-    // Convert list of nodes in NeoFS API format to the intermediate representation.
+    // Convert list of nodes in FrostFS API format to the intermediate representation.
     nodes := netmap.NodesFromInfo(nodes)
 
     // Create new netmap (errors are skipped for the sake of clarity).
@@ -110,13 +120,13 @@ func placementNodes(addr *object.Address, p *netmap.PlacementPolicy, neofsNodes
 ```
 
 ### pool
-Simple pool for managing connections to NeoFS nodes.
+Simple pool for managing connections to FrostFS nodes.
 
 ### acl, checksum, version, signature
 Contain simple API wrappers.
 
 ### logger
-Wrapper over `zap.Logger` which is used across NeoFS codebase.
+Wrapper over `zap.Logger` which is used across FrostFS codebase.
 
 ### util
 Utilities for working with signature-related code.

accounting/decimal.go

@@ -1,69 +1,64 @@
 package accounting
 
-import "github.com/nspcc-dev/neofs-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-sdk-go/api/accounting.Decimal
+// message. See ReadFromV2 / WriteToV2 methods.
+//
+// Instances can be created using built-in var declaration.
+//
+// Note that direct typecast is not safe and may result in loss of compatibility:
+//
+//	_ = Decimal(accounting.Decimal{}) // not recommended
 type Decimal accounting.Decimal
 
-// NewDecimal creates, initializes and returns empty Decimal instance.
+// ReadFromV2 reads Decimal from the accounting.Decimal message. Checks if the
+// message conforms to FrostFS API V2 protocol.
 //
-// Defaults:
+// See also WriteToV2.
-//  - value: 0
+func (d *Decimal) ReadFromV2(m accounting.Decimal) error {
-//  - precision: 0
+	*d = Decimal(m)
-func NewDecimal() *Decimal {
+	return nil
-	return NewDecimalFromV2(new(accounting.Decimal))
 }
 
-// NewDecimalFromV2 converts v2 Decimal to Decimal.
+// WriteToV2 writes Decimal to the accounting.Decimal message.
+// The message must not be nil.
 //
-// Nil Decimal converts to nil.
+// See also ReadFromV2.
-func NewDecimalFromV2(d *accounting.Decimal) *Decimal {
+func (d Decimal) WriteToV2(m *accounting.Decimal) {
-	return (*Decimal)(d)
+	*m = (accounting.Decimal)(d)
-}
-
-// ToV2 returns the v2 Decimal message.
-//
-// Nil Decimal converts to nil.
-func (d *Decimal) ToV2() *accounting.Decimal {
-	return (*accounting.Decimal)(d)
 }
 
 // Value returns value of the decimal number.
-func (d *Decimal) Value() int64 {
+//
-	return (*accounting.Decimal)(d).GetValue()
+// Zero Decimal has zero value.
+//
+// See also SetValue.
+func (d Decimal) Value() int64 {
+	return (*accounting.Decimal)(&d).GetValue()
 }
 
 // SetValue sets value of the decimal number.
+//
+// See also Value.
 func (d *Decimal) SetValue(v int64) {
 	(*accounting.Decimal)(d).SetValue(v)
 }
 
 // Precision returns precision of the decimal number.
-func (d *Decimal) Precision() uint32 {
+//
-	return (*accounting.Decimal)(d).GetPrecision()
+// Zero Decimal has zero precision.
+//
+// See also SetPrecision.
+func (d Decimal) Precision() uint32 {
+	return (*accounting.Decimal)(&d).GetPrecision()
 }
 
 // SetPrecision sets precision of the decimal number.
+//
+// See also Precision.
 func (d *Decimal) SetPrecision(p uint32) {
 	(*accounting.Decimal)(d).SetPrecision(p)
 }
-
-// Marshal marshals Decimal into a protobuf binary form.
-func (d *Decimal) Marshal() ([]byte, error) {
-	return (*accounting.Decimal)(d).StableMarshal(nil)
-}
-
-// Unmarshal unmarshalls protobuf binary representation of Decimal.
-func (d *Decimal) Unmarshal(data []byte) error {
-	return (*accounting.Decimal)(d).Unmarshal(data)
-}
-
-// MarshalJSON encodes Decimal to protobuf JSON format.
-func (d *Decimal) MarshalJSON() ([]byte, error) {
-	return (*accounting.Decimal)(d).MarshalJSON()
-}
-
-// UnmarshalJSON decodes Decimal from protobuf JSON format.
-func (d *Decimal) UnmarshalJSON(data []byte) error {
-	return (*accounting.Decimal)(d).UnmarshalJSON(data)
-}

accounting/decimal_test.go

@@ -3,15 +3,19 @@ package accounting_test
 import (
 	"testing"
 
-	"github.com/nspcc-dev/neofs-sdk-go/accounting"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting"
-	accountingtest "github.com/nspcc-dev/neofs-sdk-go/accounting/test"
+	v2accounting "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
 	"github.com/stretchr/testify/require"
 )
 
-func TestDecimal(t *testing.T) {
+func TestDecimalData(t *testing.T) {
 	const v, p = 4, 2
 
-	d := accounting.NewDecimal()
+	var d accounting.Decimal
+
+	require.Zero(t, d.Value())
+	require.Zero(t, d.Precision())
+
 	d.SetValue(v)
 	d.SetPrecision(p)
 
@@ -19,26 +23,24 @@ func TestDecimal(t *testing.T) {
 	require.EqualValues(t, p, d.Precision())
 }
 
-func TestDecimalEncoding(t *testing.T) {
+func TestDecimalMessageV2(t *testing.T) {
-	d := accountingtest.Decimal()
+	var (
+		d accounting.Decimal
+		m v2accounting.Decimal
+	)
 
-	t.Run("binary", func(t *testing.T) {
+	m.SetValue(7)
-		data, err := d.Marshal()
+	m.SetPrecision(8)
-		require.NoError(t, err)
 
-		d2 := accounting.NewDecimal()
+	require.NoError(t, d.ReadFromV2(m))
-		require.NoError(t, d2.Unmarshal(data))
 
-		require.Equal(t, d, d2)
+	require.EqualValues(t, m.GetValue(), d.Value())
-	})
+	require.EqualValues(t, m.GetPrecision(), d.Precision())
 
-	t.Run("json", func(t *testing.T) {
+	var m2 v2accounting.Decimal
-		data, err := d.MarshalJSON()
-		require.NoError(t, err)
 
-		d2 := accounting.NewDecimal()
+	d.WriteToV2(&m2)
-		require.NoError(t, d2.UnmarshalJSON(data))
 
-		require.Equal(t, d, d2)
+	require.EqualValues(t, d.Value(), m2.GetValue())
-	})
+	require.EqualValues(t, d.Precision(), m2.GetPrecision())
 }

accounting/doc.go

@@ -0,0 +1,35 @@
+/*
+Package accounting provides primitives to perform accounting operations in FrostFS.
+
+Decimal type provides functionality to process user balances. For example, when
+working with Fixed8 balance precision:
+
+	var dec accounting.Decimal
+	dec.SetValue(val)
+	dec.SetPrecision(8)
+
+Instances can be also used to process FrostFS API V2 protocol messages
+(see neo.fs.v2.accounting package in https://git.frostfs.info/TrueCloudLab/frostfs-api).
+
+On client side:
+
+	import "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/accounting"
+
+	var msg accounting.Decimal
+	dec.WriteToV2(&msg)
+
+	// send msg
+
+On server side:
+
+	// recv msg
+
+	var dec accounting.Decimal
+	dec.ReadFromV2(msg)
+
+	// process dec
+
+Using package types in an application is recommended to potentially work with
+different protocol versions with which these types are compatible.
+*/
+package accounting

accounting/test/decimal.go

@@ -3,14 +3,14 @@ package accountingtest
 import (
 	"math/rand"
 
-	"github.com/nspcc-dev/neofs-sdk-go/accounting"
+	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting"
 )
 
 // Decimal returns random accounting.Decimal.
 func Decimal() *accounting.Decimal {
-	d := accounting.NewDecimal()
+	var d accounting.Decimal
 	d.SetValue(rand.Int63())
 	d.SetPrecision(rand.Uint32())
 
-	return d
+	return &d
 }

accounting/test/doc.go

@@ -0,0 +1,13 @@
+/*
+Package accountingtest provides functions for convenient testing of accounting package API.
+
+Note that importing the package into source files is highly discouraged.
+
+Random instance generation functions can be useful when testing expects any value, e.g.:
+
+	import accountingtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting/test"
+
+	dec := accountingtest.Decimal()
+	// test the value
+*/
+package accountingtest

acl/types.go

@@ -1,105 +0,0 @@
-package acl
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-// BasicACL is Access Control List that defines who can interact with containers and what exactly they can do.
-type BasicACL uint32
-
-func (a BasicACL) String() string {
-	return fmt.Sprintf("0x%08x", uint32(a))
-}
-
-const (
-	// PublicBasicRule is a basic ACL value for final public-read-write container for which extended ACL CANNOT be set.
-	PublicBasicRule BasicACL = 0x1FBFBFFF
-
-	// PrivateBasicRule is a basic ACL value for final private container for which extended ACL CANNOT be set.
-	PrivateBasicRule BasicACL = 0x1C8C8CCC
-
-	// ReadOnlyBasicRule is a basic ACL value for final public-read container for which extended ACL CANNOT be set.
-	ReadOnlyBasicRule BasicACL = 0x1FBF8CFF
-
-	// PublicAppendRule is a basic ACL value for final public-append container for which extended ACL CANNOT be set.
-	PublicAppendRule BasicACL = 0x1FBF9FFF
-
-	// EACLPublicBasicRule is a basic ACL value for non-final public-read-write container for which extended ACL CAN be set.
-	EACLPublicBasicRule BasicACL = 0x0FBFBFFF
-
-	// EACLPrivateBasicRule is a basic ACL value for non-final private container for which extended ACL CAN be set.
-	EACLPrivateBasicRule BasicACL = 0x0C8C8CCC
-
-	// EACLReadOnlyBasicRule is a basic ACL value for non-final public-read container for which extended ACL CAN be set.
-	EACLReadOnlyBasicRule BasicACL = 0x0FBF8CFF
-
-	// EACLPublicAppendRule is a basic ACL value for non-final public-append container for which extended ACL CAN be set.
-	EACLPublicAppendRule BasicACL = 0x0FBF9FFF
-)
-
-const (
-	// PublicBasicName is a well-known name for 0x1FBFBFFF basic ACL.
-	// It represents fully-public container without eACL.
-	PublicBasicName = "public-read-write"
-
-	// PrivateBasicName is a well-known name for 0x1C8C8CCC basic ACL.
-	// It represents fully-private container without eACL.
-	PrivateBasicName = "private"
-
-	// ReadOnlyBasicName is a well-known name for 0x1FBF8CFF basic ACL.
-	// It represents public read-only container without eACL.
-	ReadOnlyBasicName = "public-read"
-
-	// PublicAppendName is a well-known name for 0x1FBF9FFF basic ACL.
-	// It represents fully-public container without eACL except DELETE operation is only allowed on the owner.
-	PublicAppendName = "public-append"
-
-	// EACLPublicBasicName is a well-known name for 0x0FBFBFFF basic ACL.
-	// It represents fully-public container that allows eACL.
-	EACLPublicBasicName = "eacl-public-read-write"
-
-	// EACLPrivateBasicName is a well-known name for 0x0C8C8CCC basic ACL.
-	// It represents fully-private container that allows eACL.
-	EACLPrivateBasicName = "eacl-private"
-
-	// EACLReadOnlyBasicName is a well-known name for 0x0FBF8CFF basic ACL.
-	// It represents public read-only container that allows eACL.
-	EACLReadOnlyBasicName = "eacl-public-read"
-
-	// EACLPublicAppendName is a well-known name for 0x0FBF9FFF basic ACL.
-	// It represents fully-public container that allows eACL except DELETE operation is only allowed on the owner.
-	EACLPublicAppendName = "eacl-public-append"
-)
-
-// ParseBasicACL parse string ACL (well-known names or hex representation).
-func ParseBasicACL(basicACL string) (BasicACL, error) {
-	switch basicACL {
-	case PublicBasicName:
-		return PublicBasicRule, nil
-	case PrivateBasicName:
-		return PrivateBasicRule, nil
-	case ReadOnlyBasicName:
-		return ReadOnlyBasicRule, nil
-	case PublicAppendName:
-		return PublicAppendRule, nil
-	case EACLPublicBasicName:
-		return EACLPublicBasicRule, nil
-	case EACLPrivateBasicName:
-		return EACLPrivateBasicRule, nil
-	case EACLReadOnlyBasicName:
-		return EACLReadOnlyBasicRule, nil
-	case EACLPublicAppendName:
-		return EACLPublicAppendRule, nil
-	default:
-		basicACL = strings.TrimPrefix(strings.ToLower(basicACL), "0x")
-
-		value, err := strconv.ParseUint(basicACL, 16, 32)
-		if err != nil {
-			return 0, fmt.Errorf("can't parse basic ACL: %s", basicACL)
-		}
-
-		return BasicACL(value), nil
-	}
-}

acl/types_test.go

@@ -1,82 +0,0 @@
-package acl
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestParser(t *testing.T) {
-	for _, tc := range []struct {
-		acl      string
-		expected BasicACL
-		err      bool
-	}{
-		{
-			acl:      PublicBasicName,
-			expected: PublicBasicRule,
-		},
-		{
-			acl:      PrivateBasicName,
-			expected: PrivateBasicRule,
-		},
-		{
-			acl:      ReadOnlyBasicName,
-			expected: ReadOnlyBasicRule,
-		},
-		{
-			acl:      PublicAppendName,
-			expected: PublicAppendRule,
-		},
-		{
-			acl:      EACLPublicBasicName,
-			expected: EACLPublicBasicRule,
-		},
-		{
-			acl:      EACLPrivateBasicName,
-			expected: EACLPrivateBasicRule,
-		},
-		{
-			acl:      EACLReadOnlyBasicName,
-			expected: EACLReadOnlyBasicRule,
-		},
-		{
-			acl:      EACLPublicAppendName,
-			expected: EACLPublicAppendRule,
-		},
-		{
-			acl:      "0x1C8C8CCC",
-			expected: 0x1C8C8CCC,
-		},
-		{
-			acl:      "1C8C8CCC",
-			expected: 0x1C8C8CCC,
-		},
-		{
-			acl: "123456789",
-			err: true,
-		},
-		{
-			acl: "0x1C8C8CCG",
-			err: true,
-		},
-	} {
-		actual, err := ParseBasicACL(tc.acl)
-		if tc.err {
-			require.Error(t, err)
-			continue
-		}
-
-		require.NoError(t, err)
-		require.Equal(t, tc.expected, actual)
-	}
-}
-
-func TestString(t *testing.T) {
-	acl := BasicACL(0x1fbfbfff)
-	require.Equal(t, "0x1fbfbfff", acl.String())
-
-	acl2, err := ParseBasicACL(PrivateBasicName)
-	require.NoError(t, err)
-	require.Equal(t, "0x1c8c8ccc", acl2.String())
-}

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)
+	})
+}