From 21d2f8f861fab4717d26609481f4c49f9ff2a339 Mon Sep 17 00:00:00 2001
From: Leonard Lyubich <leonard@nspcc.ru>
Date: Thu, 9 Jun 2022 02:18:26 +0300
Subject: [PATCH] [#1513] Upgrade NeoFS SDK Go with changed `netmap` package

Signed-off-by: Leonard Lyubich <leonard@nspcc.ru>
---
 cmd/neofs-cli/internal/client/client.go       |   4 +-
 cmd/neofs-cli/modules/container/create.go     |  20 ++-
 cmd/neofs-cli/modules/container/get.go        |  19 ++-
 cmd/neofs-cli/modules/netmap/netinfo.go       |  84 ++-------
 cmd/neofs-cli/modules/netmap/nodeinfo.go      |  24 ++-
 cmd/neofs-node/attributes.go                  |  63 +------
 cmd/neofs-node/cache.go                       |   8 +-
 cmd/neofs-node/config.go                      |  20 ++-
 cmd/neofs-node/container.go                   |  19 ++-
 cmd/neofs-node/netmap.go                      | 150 ++++++++++-------
 cmd/neofs-node/object.go                      |   8 +-
 .../reputation/intermediate/calculator.go     |   2 +-
 cmd/neofs-node/reputation/local/storage.go    |  11 +-
 go.mod                                        |   2 +-
 go.sum                                        | Bin 98718 -> 98718 bytes
 pkg/core/container/fmt_test.go                |   6 +-
 pkg/core/netmap/nodes.go                      |  31 ++++
 pkg/core/netmap/storage.go                    |   8 +-
 .../processors/alphabet/process_emit.go       |   8 +-
 pkg/innerring/processors/audit/process.go     |  20 ++-
 .../processors/container/process_container.go |  11 +-
 .../processors/netmap/cleanup_table.go        |  16 +-
 .../processors/netmap/cleanup_table_test.go   |   7 +-
 .../netmap/nodevalidation/locode/calls.go     |  87 +++++-----
 .../nodevalidation/locode/calls_test.go       |  81 ++-------
 .../netmap/nodevalidation/locode/util.go      |  30 ----
 .../netmap/nodevalidation/locode/validator.go |  17 --
 .../netmap/nodevalidation/maddress/calls.go   |   2 +-
 .../processors/netmap/process_cleanup.go      |   5 +-
 .../processors/netmap/process_epoch.go        |   2 +-
 .../processors/netmap/process_peers.go        |  52 ++----
 pkg/innerring/rpc.go                          |  13 +-
 pkg/innerring/settlement.go                   |  23 ++-
 pkg/innerring/subnet.go                       |  17 +-
 pkg/morph/client/netmap/add_peer.go           |  15 +-
 pkg/morph/client/netmap/config.go             | 121 +++++++------
 pkg/morph/client/netmap/netmap.go             |  29 +---
 pkg/morph/client/netmap/netmap_test.go        |  26 +--
 pkg/morph/client/netmap/snapshot.go           |  13 +-
 pkg/morph/client/netmap/update_state.go       |  17 +-
 pkg/morph/event/netmap/update_peer.go         |  16 +-
 pkg/morph/event/netmap/update_peer_notary.go  |  15 +-
 pkg/morph/event/netmap/update_peer_test.go    |  10 +-
 pkg/network/group.go                          |   3 +-
 pkg/network/validation.go                     |  16 +-
 pkg/network/validation_test.go                |   7 +-
 pkg/services/audit/auditor/context.go         |  19 ++-
 pkg/services/audit/auditor/pdp.go             |  16 +-
 pkg/services/audit/auditor/pop.go             |  18 +-
 pkg/services/audit/auditor/por.go             |   2 +-
 pkg/services/audit/task.go                    |  12 +-
 .../load/route/placement/calls.go             |   7 +-
 .../announcement/load/route/placement/deps.go |   2 +-
 .../control/server/netmap_snapshot.go         |  56 +++---
 pkg/services/netmap/executor.go               |  18 +-
 pkg/services/object/acl/v2/classifier.go      |  18 +-
 pkg/services/object/get/get_test.go           |  48 +++---
 pkg/services/object/head/remote.go            |   7 +-
 pkg/services/object/put/remote.go             |   7 +-
 pkg/services/object/search/search_test.go     |  47 +++---
 pkg/services/object/util/placement.go         |  10 +-
 .../object_manager/placement/netmap.go        |  31 ++--
 .../object_manager/placement/traverser.go     |  22 +--
 .../placement/traverser_test.go               |  41 ++---
 pkg/services/policer/check.go                 |  24 ++-
 pkg/services/replicator/process.go            |   4 +-
 pkg/services/replicator/task.go               |   4 +-
 pkg/services/reputation/common/managers.go    |  25 ++-
 pkg/util/attributes/parser.go                 | 111 ++++--------
 pkg/util/attributes/parser_test.go            | 159 ++++++++----------
 70 files changed, 876 insertions(+), 990 deletions(-)
 create mode 100644 pkg/core/netmap/nodes.go
 delete mode 100644 pkg/innerring/processors/netmap/nodevalidation/locode/util.go

diff --git a/cmd/neofs-cli/internal/client/client.go b/cmd/neofs-cli/internal/client/client.go
index 3ae06a03e..28a655fe2 100644
--- a/cmd/neofs-cli/internal/client/client.go
+++ b/cmd/neofs-cli/internal/client/client.go
@@ -244,8 +244,8 @@ type NodeInfoRes struct {
 }
 
 // NodeInfo returns information about the node from netmap.
-func (x NodeInfoRes) NodeInfo() *netmap.NodeInfo {
-	return x.cliRes.NodeInfo()
+func (x NodeInfoRes) NodeInfo() netmap.NodeInfo {
+	return *x.cliRes.NodeInfo()
 }
 
 // LatestVersion returns the latest NeoFS API version in use.
diff --git a/cmd/neofs-cli/modules/container/create.go b/cmd/neofs-cli/modules/container/create.go
index 4084381c7..bf7336fbe 100644
--- a/cmd/neofs-cli/modules/container/create.go
+++ b/cmd/neofs-cli/modules/container/create.go
@@ -16,7 +16,6 @@ import (
 	"github.com/nspcc-dev/neofs-sdk-go/acl"
 	"github.com/nspcc-dev/neofs-sdk-go/container"
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
-	"github.com/nspcc-dev/neofs-sdk-go/policy"
 	"github.com/nspcc-dev/neofs-sdk-go/session"
 	subnetid "github.com/nspcc-dev/neofs-sdk-go/subnet/id"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
@@ -69,12 +68,14 @@ It will be stored in sidechain when inner ring will accepts it.`,
 		placementPolicy, err := parseContainerPolicy(containerPolicy)
 		common.ExitOnErr(cmd, "", err)
 
-		var subnetID subnetid.ID
+		if containerSubnet != "" {
+			var subnetID subnetid.ID
 
-		err = subnetID.DecodeString(containerSubnet)
-		common.ExitOnErr(cmd, "could not parse subnetID: %w", err)
+			err = subnetID.DecodeString(containerSubnet)
+			common.ExitOnErr(cmd, "could not parse subnetID: %w", err)
 
-		placementPolicy.SetSubnetID(&subnetID)
+			placementPolicy.RestrictSubnet(subnetID)
+		}
 
 		attributes, err := parseAttributes(containerAttributes)
 		common.ExitOnErr(cmd, "", err)
@@ -177,16 +178,17 @@ func parseContainerPolicy(policyString string) (*netmap.PlacementPolicy, error)
 		policyString = string(data)
 	}
 
-	result, err := policy.Parse(policyString)
+	var result netmap.PlacementPolicy
+
+	err = result.DecodeString(policyString)
 	if err == nil {
 		common.PrintVerbose("Parsed QL encoded policy")
-		return result, nil
+		return &result, nil
 	}
 
-	result = netmap.NewPlacementPolicy()
 	if err = result.UnmarshalJSON([]byte(policyString)); err == nil {
 		common.PrintVerbose("Parsed JSON encoded policy")
-		return result, nil
+		return &result, nil
 	}
 
 	return nil, errors.New("can't parse placement policy")
diff --git a/cmd/neofs-cli/modules/container/get.go b/cmd/neofs-cli/modules/container/get.go
index 2ec6dcb12..1bdd19221 100644
--- a/cmd/neofs-cli/modules/container/get.go
+++ b/cmd/neofs-cli/modules/container/get.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"os"
-	"strings"
 
 	internalclient "github.com/nspcc-dev/neofs-node/cmd/neofs-cli/internal/client"
 	"github.com/nspcc-dev/neofs-node/cmd/neofs-cli/internal/common"
@@ -12,7 +11,6 @@ import (
 	"github.com/nspcc-dev/neofs-node/cmd/neofs-cli/internal/key"
 	"github.com/nspcc-dev/neofs-sdk-go/acl"
 	"github.com/nspcc-dev/neofs-sdk-go/container"
-	"github.com/nspcc-dev/neofs-sdk-go/policy"
 	"github.com/spf13/cobra"
 )
 
@@ -85,6 +83,13 @@ func initContainerInfoCmd() {
 	flags.BoolVar(&containerJSON, "json", false, "print or dump container in JSON format")
 }
 
+type stringWriter cobra.Command
+
+func (x *stringWriter) WriteString(s string) (n int, err error) {
+	(*cobra.Command)(x).Print(s)
+	return len(s), nil
+}
+
 func prettyPrintContainer(cmd *cobra.Command, cnr *container.Container, jsonEncoding bool) {
 	if cnr == nil {
 		return
@@ -137,8 +142,14 @@ func prettyPrintContainer(cmd *cobra.Command, cnr *container.Container, jsonEnco
 		cmd.Println("invalid nonce:", err)
 	}
 
-	cmd.Println("placement policy:")
-	cmd.Println(strings.Join(policy.Encode(cnr.PlacementPolicy()), "\n"))
+	pp := cnr.PlacementPolicy()
+	if pp == nil {
+		cmd.Println("missing placement policy")
+	} else {
+		cmd.Println("placement policy:")
+		common.ExitOnErr(cmd, "write policy: %w", pp.WriteStringTo((*stringWriter)(cmd)))
+		cmd.Println()
+	}
 }
 
 func prettyPrintBasicACL(cmd *cobra.Command, basicACL acl.BasicACL) {
diff --git a/cmd/neofs-cli/modules/netmap/netinfo.go b/cmd/neofs-cli/modules/netmap/netinfo.go
index f02c6800c..9e230aa66 100644
--- a/cmd/neofs-cli/modules/netmap/netinfo.go
+++ b/cmd/neofs-cli/modules/netmap/netinfo.go
@@ -9,13 +9,9 @@ import (
 	"github.com/nspcc-dev/neofs-node/cmd/neofs-cli/internal/common"
 	"github.com/nspcc-dev/neofs-node/cmd/neofs-cli/internal/commonflags"
 	"github.com/nspcc-dev/neofs-node/cmd/neofs-cli/internal/key"
-	nmClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 	"github.com/spf13/cobra"
 )
 
-type netCfgWriter cobra.Command
-
 var netInfoCmd = &cobra.Command{
 	Use:   "netinfo",
 	Short: "Get information about NeoFS network",
@@ -39,21 +35,23 @@ var netInfoCmd = &cobra.Command{
 
 		cmd.Printf("Time per block: %s\n", time.Duration(netInfo.MsPerBlock())*time.Millisecond)
 
-		netCfg := netInfo.NetworkConfig()
+		const format = "  %s: %v\n"
 
-		cmd.Println("NeoFS network configuration")
+		cmd.Println("NeoFS network configuration (system)")
+		cmd.Printf(format, "Audit fee", netInfo.AuditFee())
+		cmd.Printf(format, "Storage price", netInfo.StoragePrice())
+		cmd.Printf(format, "Container fee", netInfo.ContainerFee())
+		cmd.Printf(format, "EigenTrust alpha", netInfo.EigenTrustAlpha())
+		cmd.Printf(format, "Number of EigenTrust iterations", netInfo.NumberOfEigenTrustIterations())
+		cmd.Printf(format, "Epoch duration", netInfo.EpochDuration())
+		cmd.Printf(format, "Inner Ring candidate fee", netInfo.IRCandidateFee())
+		cmd.Printf(format, "Maximum object size", netInfo.MaxObjectSize())
+		cmd.Printf(format, "Withdrawal fee", netInfo.WithdrawalFee())
 
-		err = nmClient.WriteConfig((*netCfgWriter)(cmd), func(f func(key []byte, val []byte) error) error {
-			var err error
-
-			netCfg.IterateParameters(func(prm *netmap.NetworkParameter) bool {
-				err = f(prm.Key(), prm.Value())
-				return err != nil
-			})
-
-			return err
+		cmd.Println("NeoFS network configuration (other)")
+		netInfo.IterateRawNetworkParameters(func(name string, value []byte) {
+			cmd.Printf(format, name, hex.EncodeToString(value))
 		})
-		common.ExitOnErr(cmd, "read config: %w", err)
 	},
 }
 
@@ -61,57 +59,3 @@ func initNetInfoCmd() {
 	commonflags.Init(netInfoCmd)
 	commonflags.InitAPI(netInfoCmd)
 }
-
-func (x *netCfgWriter) print(name string, v interface{}, unknown bool) {
-	var sUnknown string
-
-	if unknown {
-		sUnknown = " (unknown)"
-	}
-
-	(*cobra.Command)(x).Printf("  %s%s: %v\n", name, sUnknown, v)
-}
-
-func (x *netCfgWriter) UnknownParameter(k string, v []byte) {
-	x.print(k, hex.EncodeToString(v), true)
-}
-
-func (x *netCfgWriter) MaxObjectSize(v uint64) {
-	x.print("Maximum object size", v, false)
-}
-
-func (x *netCfgWriter) BasicIncomeRate(v uint64) {
-	x.print("Basic income rate", v, false)
-}
-
-func (x *netCfgWriter) AuditFee(v uint64) {
-	x.print("Audit fee", v, false)
-}
-
-func (x *netCfgWriter) EpochDuration(v uint64) {
-	x.print("Epoch duration", v, false)
-}
-
-func (x *netCfgWriter) ContainerFee(v uint64) {
-	x.print("Container fee", v, false)
-}
-
-func (x *netCfgWriter) ContainerAliasFee(v uint64) {
-	x.print("Container alias fee", v, false)
-}
-
-func (x *netCfgWriter) EigenTrustIterations(v uint64) {
-	x.print("Number EigenTrust of iterations", v, false)
-}
-
-func (x *netCfgWriter) EigenTrustAlpha(v float64) {
-	x.print("EigenTrust α", v, false)
-}
-
-func (x *netCfgWriter) InnerRingCandidateFee(v uint64) {
-	x.print("Inner Ring candidate fee", v, false)
-}
-
-func (x *netCfgWriter) WithdrawFee(v uint64) {
-	x.print("Withdraw fee", v, false)
-}
diff --git a/cmd/neofs-cli/modules/netmap/nodeinfo.go b/cmd/neofs-cli/modules/netmap/nodeinfo.go
index ee397086c..0f44b7c5e 100644
--- a/cmd/neofs-cli/modules/netmap/nodeinfo.go
+++ b/cmd/neofs-cli/modules/netmap/nodeinfo.go
@@ -37,7 +37,7 @@ func initNodeInfoCmd() {
 	nodeInfoCmd.Flags().Bool(nodeInfoJSONFlag, false, "print node info in JSON format")
 }
 
-func prettyPrintNodeInfo(cmd *cobra.Command, i *netmap.NodeInfo) {
+func prettyPrintNodeInfo(cmd *cobra.Command, i netmap.NodeInfo) {
 	isJSON, _ := cmd.Flags().GetBool(nodeInfoJSONFlag)
 	if isJSON {
 		common.PrettyPrintJSON(cmd, i, "node info")
@@ -45,12 +45,24 @@ func prettyPrintNodeInfo(cmd *cobra.Command, i *netmap.NodeInfo) {
 	}
 
 	cmd.Println("key:", hex.EncodeToString(i.PublicKey()))
-	cmd.Println("state:", i.State())
-	netmap.IterateAllAddresses(i, func(s string) {
+
+	var stateWord string
+	switch {
+	default:
+		stateWord = "<undefined>"
+	case i.IsOnline():
+		stateWord = "online"
+	case i.IsOffline():
+		stateWord = "offline"
+	}
+
+	cmd.Println("state:", stateWord)
+
+	netmap.IterateNetworkEndpoints(i, func(s string) {
 		cmd.Println("address:", s)
 	})
 
-	for _, attribute := range i.Attributes() {
-		cmd.Printf("attribute: %s=%s\n", attribute.Key(), attribute.Value())
-	}
+	i.IterateAttributes(func(key, value string) {
+		cmd.Printf("attribute: %s=%s\n", key, value)
+	})
 }
diff --git a/cmd/neofs-node/attributes.go b/cmd/neofs-node/attributes.go
index d4f962dbe..cf1b05244 100644
--- a/cmd/neofs-node/attributes.go
+++ b/cmd/neofs-node/attributes.go
@@ -1,69 +1,14 @@
 package main
 
 import (
-	"fmt"
-	"strconv"
-
-	"github.com/nspcc-dev/neofs-node/cmd/neofs-node/config"
 	nodeconfig "github.com/nspcc-dev/neofs-node/cmd/neofs-node/config/node"
 	"github.com/nspcc-dev/neofs-node/pkg/util/attributes"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 )
 
-const (
-	// list of default values for well-known attributes
-	defaultCapacity = 0
-	defaultPrice    = 0
-)
-
-func parseAttributes(c *config.Config) []netmap.NodeAttribute {
-	if nodeconfig.Relay(c) {
-		return nil
+func parseAttributes(c *cfg) {
+	if nodeconfig.Relay(c.appCfg) {
+		return
 	}
 
-	stringAttributes := nodeconfig.Attributes(c)
-
-	attrs, err := attributes.ParseV2Attributes(stringAttributes, nil)
-	if err != nil {
-		fatalOnErr(err)
-	}
-
-	return addWellKnownAttributes(attrs)
-}
-
-type wellKnownNodeAttrDesc struct {
-	explicit   bool
-	defaultVal string
-}
-
-func listWellKnownAttrDesc() map[string]wellKnownNodeAttrDesc {
-	return map[string]wellKnownNodeAttrDesc{
-		netmap.AttrPrice:    {defaultVal: strconv.FormatUint(defaultPrice, 10)},
-		netmap.AttrCapacity: {defaultVal: strconv.FormatUint(defaultCapacity, 10)},
-		netmap.AttrUNLOCODE: {explicit: true},
-	}
-}
-
-func addWellKnownAttributes(attrs []netmap.NodeAttribute) []netmap.NodeAttribute {
-	mWellKnown := listWellKnownAttrDesc()
-
-	// check how user defined well-known attributes
-	for i := range attrs {
-		delete(mWellKnown, attrs[i].Key())
-	}
-
-	for key, desc := range mWellKnown {
-		// check if required attribute is set
-		if desc.explicit {
-			fatalOnErr(fmt.Errorf("missing explicit value of required node attribute %s", key))
-		}
-
-		// set default value of the attribute
-		index := len(attrs)
-		attrs = append(attrs, netmap.NodeAttribute{})
-		attrs[index].SetKey(key)
-		attrs[index].SetValue(desc.defaultVal)
-	}
-
-	return attrs
+	fatalOnErr(attributes.ReadNodeAttributes(&c.cfgNodeInfo.localInfo, nodeconfig.Attributes(c.appCfg)))
 }
diff --git a/cmd/neofs-node/cache.go b/cmd/neofs-node/cache.go
index 84952465a..b65f214c6 100644
--- a/cmd/neofs-node/cache.go
+++ b/cmd/neofs-node/cache.go
@@ -213,21 +213,21 @@ func newCachedNetmapStorage(s netmap.State, v netmap.Source) netmap.Source {
 	}
 }
 
-func (s *lruNetmapSource) GetNetMap(diff uint64) (*netmapSDK.Netmap, error) {
+func (s *lruNetmapSource) GetNetMap(diff uint64) (*netmapSDK.NetMap, error) {
 	return s.getNetMapByEpoch(s.netState.CurrentEpoch() - diff)
 }
 
-func (s *lruNetmapSource) GetNetMapByEpoch(epoch uint64) (*netmapSDK.Netmap, error) {
+func (s *lruNetmapSource) GetNetMapByEpoch(epoch uint64) (*netmapSDK.NetMap, error) {
 	return s.getNetMapByEpoch(epoch)
 }
 
-func (s *lruNetmapSource) getNetMapByEpoch(epoch uint64) (*netmapSDK.Netmap, error) {
+func (s *lruNetmapSource) getNetMapByEpoch(epoch uint64) (*netmapSDK.NetMap, error) {
 	val, err := s.cache.get(epoch)
 	if err != nil {
 		return nil, err
 	}
 
-	return val.(*netmapSDK.Netmap), nil
+	return val.(*netmapSDK.NetMap), nil
 }
 
 func (s *lruNetmapSource) Epoch() (uint64, error) {
diff --git a/cmd/neofs-node/config.go b/cmd/neofs-node/config.go
index 6ce5772e5..dcae1dd3a 100644
--- a/cmd/neofs-node/config.go
+++ b/cmd/neofs-node/config.go
@@ -480,15 +480,21 @@ func initObjectPool(cfg *config.Config) (pool cfgObjectRoutines) {
 }
 
 func (c *cfg) LocalNodeInfo() (*netmapV2.NodeInfo, error) {
-	ni := c.cfgNetmap.state.getNodeInfo()
-	if ni != nil {
-		return ni.ToV2(), nil
+	var res netmapV2.NodeInfo
+
+	ni, ok := c.cfgNetmap.state.getNodeInfo()
+	if ok {
+		ni.WriteToV2(&res)
+	} else {
+		c.cfgNodeInfo.localInfo.WriteToV2(&res)
 	}
 
-	return c.cfgNodeInfo.localInfo.ToV2(), nil
+	return &res, nil
 }
 
-// handleLocalNodeInfo rewrites local node info from netmap
+// handleLocalNodeInfo rewrites local node info from the NeoFS network map.
+// Called with nil when storage node is outside the NeoFS network map
+// (before entering the network and after leaving it).
 func (c *cfg) handleLocalNodeInfo(ni *netmap.NodeInfo) {
 	c.cfgNetmap.state.setNodeInfo(ni)
 }
@@ -496,10 +502,10 @@ func (c *cfg) handleLocalNodeInfo(ni *netmap.NodeInfo) {
 // bootstrap sets local node's netmap status to "online".
 func (c *cfg) bootstrap() error {
 	ni := c.cfgNodeInfo.localInfo
-	ni.SetState(netmap.NodeStateOnline)
+	ni.SetOnline()
 
 	prm := nmClient.AddPeerPrm{}
-	prm.SetNodeInfo(&ni)
+	prm.SetNodeInfo(ni)
 
 	return c.cfgNetmap.wrapper.AddPeer(prm)
 }
diff --git a/cmd/neofs-node/container.go b/cmd/neofs-node/container.go
index 4e708089e..0b30af5fc 100644
--- a/cmd/neofs-node/container.go
+++ b/cmd/neofs-node/container.go
@@ -329,7 +329,7 @@ type loadPlacementBuilder struct {
 	cnrSrc containerCore.Source
 }
 
-func (l *loadPlacementBuilder) BuildPlacement(epoch uint64, cnr cid.ID) ([]netmap.Nodes, error) {
+func (l *loadPlacementBuilder) BuildPlacement(epoch uint64, cnr cid.ID) ([][]netmap.NodeInfo, error) {
 	cnrNodes, nm, err := l.buildPlacement(epoch, cnr)
 	if err != nil {
 		return nil, err
@@ -341,7 +341,7 @@ func (l *loadPlacementBuilder) BuildPlacement(epoch uint64, cnr cid.ID) ([]netma
 		pivotPrefix + strconv.FormatUint(epoch, 10),
 	)
 
-	placement, err := nm.GetPlacementVectors(cnrNodes, pivot)
+	placement, err := nm.PlacementVectors(cnrNodes, pivot)
 	if err != nil {
 		return nil, fmt.Errorf("could not build placement vectors: %w", err)
 	}
@@ -349,12 +349,17 @@ func (l *loadPlacementBuilder) BuildPlacement(epoch uint64, cnr cid.ID) ([]netma
 	return placement, nil
 }
 
-func (l *loadPlacementBuilder) buildPlacement(epoch uint64, idCnr cid.ID) (netmap.ContainerNodes, *netmap.Netmap, error) {
+func (l *loadPlacementBuilder) buildPlacement(epoch uint64, idCnr cid.ID) ([][]netmap.NodeInfo, *netmap.NetMap, error) {
 	cnr, err := l.cnrSrc.Get(idCnr)
 	if err != nil {
 		return nil, nil, err
 	}
 
+	policy := cnr.PlacementPolicy()
+	if policy == nil {
+		return nil, nil, errors.New("missing placement policy in container")
+	}
+
 	nm, err := l.nmSrc.GetNetMapByEpoch(epoch)
 	if err != nil {
 		return nil, nil, fmt.Errorf("could not get network map: %w", err)
@@ -363,7 +368,7 @@ func (l *loadPlacementBuilder) buildPlacement(epoch uint64, idCnr cid.ID) (netma
 	binCnr := make([]byte, sha256.Size)
 	idCnr.Encode(binCnr)
 
-	cnrNodes, err := nm.GetContainerNodes(cnr.PlacementPolicy(), binCnr)
+	cnrNodes, err := nm.ContainerNodes(*policy, binCnr)
 	if err != nil {
 		return nil, nil, fmt.Errorf("could not build container nodes: %w", err)
 	}
@@ -512,9 +517,9 @@ func (l *loadPlacementBuilder) isNodeFromContainerKey(epoch uint64, cnr cid.ID,
 		return false, err
 	}
 
-	for _, vector := range cnrNodes.Replicas() {
-		for _, node := range vector {
-			if bytes.Equal(node.PublicKey(), key) {
+	for i := range cnrNodes {
+		for j := range cnrNodes[i] {
+			if bytes.Equal(cnrNodes[i][j].PublicKey(), key) {
 				return true, nil
 			}
 		}
diff --git a/cmd/neofs-node/netmap.go b/cmd/neofs-node/netmap.go
index f79d7145f..8f5c58646 100644
--- a/cmd/neofs-node/netmap.go
+++ b/cmd/neofs-node/netmap.go
@@ -5,9 +5,7 @@ import (
 	"errors"
 	"fmt"
 
-	netmapV2 "github.com/nspcc-dev/neofs-api-go/v2/netmap"
 	netmapGRPC "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
-	"github.com/nspcc-dev/neofs-api-go/v2/refs"
 	nodeconfig "github.com/nspcc-dev/neofs-node/cmd/neofs-node/config/node"
 	"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/metrics"
@@ -20,6 +18,7 @@ import (
 	netmapService "github.com/nspcc-dev/neofs-node/pkg/services/netmap"
 	netmapSDK "github.com/nspcc-dev/neofs-sdk-go/netmap"
 	subnetid "github.com/nspcc-dev/neofs-sdk-go/subnet/id"
+	"github.com/nspcc-dev/neofs-sdk-go/version"
 	"go.uber.org/atomic"
 	"go.uber.org/zap"
 )
@@ -53,16 +52,18 @@ func (s *networkState) setCurrentEpoch(v uint64) {
 }
 
 func (s *networkState) setNodeInfo(ni *netmapSDK.NodeInfo) {
-	s.nodeInfo.Store(ni)
+	ctrlNetSt := control.NetmapStatus_STATUS_UNDEFINED
 
-	var ctrlNetSt control.NetmapStatus
+	if ni != nil {
+		s.nodeInfo.Store(*ni)
 
-	switch ni.State() {
-	default:
-		ctrlNetSt = control.NetmapStatus_STATUS_UNDEFINED
-	case netmapSDK.NodeStateOnline:
-		ctrlNetSt = control.NetmapStatus_ONLINE
-	case netmapSDK.NodeStateOffline:
+		switch {
+		case ni.IsOnline():
+			ctrlNetSt = control.NetmapStatus_ONLINE
+		case ni.IsOffline():
+			ctrlNetSt = control.NetmapStatus_OFFLINE
+		}
+	} else {
 		ctrlNetSt = control.NetmapStatus_OFFLINE
 	}
 
@@ -73,27 +74,48 @@ func (s *networkState) controlNetmapStatus() control.NetmapStatus {
 	return s.controlNetStatus.Load().(control.NetmapStatus)
 }
 
-func (s *networkState) getNodeInfo() *netmapSDK.NodeInfo {
-	return s.nodeInfo.Load().(*netmapSDK.NodeInfo)
+func (s *networkState) getNodeInfo() (res netmapSDK.NodeInfo, ok bool) {
+	v := s.nodeInfo.Load()
+	if v != nil {
+		res, ok = v.(netmapSDK.NodeInfo)
+		if !ok {
+			panic(fmt.Sprintf("unexpected value in atomic node info state: %T", v))
+		}
+	}
+
+	return
 }
 
 func nodeKeyFromNetmap(c *cfg) []byte {
-	return c.cfgNetmap.state.getNodeInfo().PublicKey()
+	ni, ok := c.cfgNetmap.state.getNodeInfo()
+	if ok {
+		return ni.PublicKey()
+	}
+
+	return nil
 }
 
 func (c *cfg) iterateNetworkAddresses(f func(string) bool) {
-	c.cfgNetmap.state.getNodeInfo().IterateAddresses(f)
+	ni, ok := c.cfgNetmap.state.getNodeInfo()
+	if ok {
+		ni.IterateNetworkEndpoints(f)
+	}
 }
 
 func (c *cfg) addressNum() int {
-	return c.cfgNetmap.state.getNodeInfo().NumberOfAddresses()
+	ni, ok := c.cfgNetmap.state.getNodeInfo()
+	if ok {
+		return ni.NumberOfNetworkEndpoints()
+	}
+
+	return 0
 }
 
 func initNetmapService(c *cfg) {
 	network.WriteToNodeInfo(c.localAddr, &c.cfgNodeInfo.localInfo)
 	c.cfgNodeInfo.localInfo.SetPublicKey(c.key.PublicKey().Bytes())
-	c.cfgNodeInfo.localInfo.SetAttributes(parseAttributes(c.appCfg)...)
-	c.cfgNodeInfo.localInfo.SetState(netmapSDK.NodeStateOffline)
+	parseAttributes(c)
+	c.cfgNodeInfo.localInfo.SetOffline()
 
 	readSubnetCfg(c)
 
@@ -111,10 +133,10 @@ func initNetmapService(c *cfg) {
 					c,
 					c.apiVersion,
 					&netInfo{
-						netState:      c.cfgNetmap.state,
-						magic:         c.cfgMorph.client,
-						netCfg:        c.cfgNetmap.wrapper.IterateConfigParameters,
-						msPerBlockRdr: c.cfgMorph.client.MsPerBlock,
+						netState:          c.cfgNetmap.state,
+						magic:             c.cfgMorph.client,
+						morphClientNetMap: c.cfgNetmap.wrapper,
+						msPerBlockRdr:     c.cfgMorph.client.MsPerBlock,
 					},
 				),
 				c.respSvc,
@@ -236,14 +258,25 @@ func initNetmapState(c *cfg) {
 	ni, err := c.netmapLocalNodeState(epoch)
 	fatalOnErrDetails("could not init network state", err)
 
+	stateWord := "undefined"
+
+	if ni != nil {
+		switch {
+		case ni.IsOnline():
+			stateWord = "online"
+		case ni.IsOffline():
+			stateWord = "offline"
+		}
+	}
+
 	c.log.Info("initial network state",
 		zap.Uint64("epoch", epoch),
-		zap.Stringer("state", ni.State()),
+		zap.String("state", stateWord),
 	)
 
 	c.cfgNetmap.state.setCurrentEpoch(epoch)
 	c.cfgNetmap.startEpoch = epoch
-	c.cfgNetmap.state.setNodeInfo(ni)
+	c.handleLocalNodeInfo(ni)
 }
 
 func (c *cfg) netmapLocalNodeState(epoch uint64) (*netmapSDK.NodeInfo, error) {
@@ -253,17 +286,14 @@ func (c *cfg) netmapLocalNodeState(epoch uint64) (*netmapSDK.NodeInfo, error) {
 		return nil, err
 	}
 
-	return c.localNodeInfoFromNetmap(nm), nil
-}
-
-func (c *cfg) localNodeInfoFromNetmap(nm *netmapSDK.Netmap) *netmapSDK.NodeInfo {
-	for _, n := range nm.Nodes {
-		if bytes.Equal(n.PublicKey(), c.key.PublicKey().Bytes()) {
-			return n.NodeInfo
+	nmNodes := nm.Nodes()
+	for i := range nmNodes {
+		if bytes.Equal(nmNodes[i].PublicKey(), c.key.PublicKey().Bytes()) {
+			return &nmNodes[i], nil
 		}
 	}
 
-	return nil
+	return nil, nil
 }
 
 // addNewEpochNotificationHandler adds handler that will be executed synchronously
@@ -309,18 +339,11 @@ func (c *cfg) SetNetmapStatus(st control.NetmapStatus) error {
 		return c.bootstrap()
 	}
 
-	var apiState netmapSDK.NodeState
-
-	if st == control.NetmapStatus_OFFLINE {
-		apiState = netmapSDK.NodeStateOffline
-	}
-
 	c.cfgNetmap.reBoostrapTurnedOff.Store(true)
 
 	prm := nmClient.UpdatePeerPrm{}
 
 	prm.SetKey(c.key.PublicKey().Bytes())
-	prm.SetState(apiState)
 
 	return c.cfgNetmap.wrapper.UpdatePeerState(prm)
 }
@@ -332,50 +355,49 @@ type netInfo struct {
 		MagicNumber() (uint64, error)
 	}
 
-	netCfg func(func(key, value []byte) error) error
+	morphClientNetMap *nmClient.Client
 
 	msPerBlockRdr func() (int64, error)
 }
 
-func (n *netInfo) Dump(ver *refs.Version) (*netmapV2.NetworkInfo, error) {
+func (n *netInfo) Dump(ver version.Version) (*netmapSDK.NetworkInfo, error) {
 	magic, err := n.magic.MagicNumber()
 	if err != nil {
 		return nil, err
 	}
 
-	ni := new(netmapV2.NetworkInfo)
+	var ni netmapSDK.NetworkInfo
 	ni.SetCurrentEpoch(n.netState.CurrentEpoch())
 	ni.SetMagicNumber(magic)
 
-	if mjr := ver.GetMajor(); mjr > 2 || mjr == 2 && ver.GetMinor() > 9 {
+	netInfoMorph, err := n.morphClientNetMap.ReadNetworkConfiguration()
+	if err != nil {
+		return nil, fmt.Errorf("read network configuration using netmap contract client: %w", err)
+	}
+
+	if mjr := ver.Major(); mjr > 2 || mjr == 2 && ver.Minor() > 9 {
 		msPerBlock, err := n.msPerBlockRdr()
 		if err != nil {
 			return nil, fmt.Errorf("ms per block: %w", err)
 		}
 
-		var (
-			ps     []netmapV2.NetworkParameter
-			netCfg netmapV2.NetworkConfig
-		)
-
-		if err := n.netCfg(func(key, value []byte) error {
-			var p netmapV2.NetworkParameter
-
-			p.SetKey(key)
-			p.SetValue(value)
-
-			ps = append(ps, p)
-
-			return nil
-		}); err != nil {
-			return nil, fmt.Errorf("network config: %w", err)
-		}
-
-		netCfg.SetParameters(ps...)
-
-		ni.SetNetworkConfig(&netCfg)
 		ni.SetMsPerBlock(msPerBlock)
+
+		ni.SetMaxObjectSize(netInfoMorph.MaxObjectSize)
+		ni.SetStoragePrice(netInfoMorph.StoragePrice)
+		ni.SetAuditFee(netInfoMorph.AuditFee)
+		ni.SetEpochDuration(netInfoMorph.EpochDuration)
+		ni.SetContainerFee(netInfoMorph.ContainerFee)
+		ni.SetNamedContainerFee(netInfoMorph.ContainerAliasFee)
+		ni.SetNumberOfEigenTrustIterations(netInfoMorph.EigenTrustIterations)
+		ni.SetEigenTrustAlpha(netInfoMorph.EigenTrustAlpha)
+		ni.SetIRCandidateFee(netInfoMorph.IRCandidateFee)
+		ni.SetWithdrawalFee(netInfoMorph.WithdrawalFee)
+
+		for i := range netInfoMorph.Raw {
+			ni.SetRawNetworkParameter(netInfoMorph.Raw[i].Name, netInfoMorph.Raw[i].Value)
+		}
 	}
 
-	return ni, nil
+	return &ni, nil
 }
diff --git a/cmd/neofs-node/object.go b/cmd/neofs-node/object.go
index b5a5f6651..441e5de69 100644
--- a/cmd/neofs-node/object.go
+++ b/cmd/neofs-node/object.go
@@ -530,10 +530,12 @@ func (c *reputationClientConstructor) Get(info coreclient.NodeInfo) (coreclient.
 	if err == nil {
 		key := info.PublicKey()
 
-		for i := range nm.Nodes {
-			if bytes.Equal(nm.Nodes[i].PublicKey(), key) {
+		nmNodes := nm.Nodes()
+
+		for i := range nmNodes {
+			if bytes.Equal(nmNodes[i].PublicKey(), key) {
 				prm := truststorage.UpdatePrm{}
-				prm.SetPeer(reputation.PeerIDFromBytes(nm.Nodes[i].PublicKey()))
+				prm.SetPeer(reputation.PeerIDFromBytes(nmNodes[i].PublicKey()))
 
 				return &reputationClient{
 					MultiAddressClient: cl.(coreclient.MultiAddressClient),
diff --git a/cmd/neofs-node/reputation/intermediate/calculator.go b/cmd/neofs-node/reputation/intermediate/calculator.go
index 64fb6abcb..51ac3f183 100644
--- a/cmd/neofs-node/reputation/intermediate/calculator.go
+++ b/cmd/neofs-node/reputation/intermediate/calculator.go
@@ -26,7 +26,7 @@ func (i InitialTrustSource) InitialTrust(reputation.PeerID) (reputation.TrustVal
 		return reputation.TrustZero, fmt.Errorf("failed to get NetMap: %w", err)
 	}
 
-	nodeCount := reputation.TrustValueFromFloat64(float64(len(nm.Nodes)))
+	nodeCount := reputation.TrustValueFromFloat64(float64(len(nm.Nodes())))
 	if nodeCount == 0 {
 		return reputation.TrustZero, ErrEmptyNetMap
 	}
diff --git a/cmd/neofs-node/reputation/local/storage.go b/cmd/neofs-node/reputation/local/storage.go
index f9ef2099d..347e6464d 100644
--- a/cmd/neofs-node/reputation/local/storage.go
+++ b/cmd/neofs-node/reputation/local/storage.go
@@ -66,14 +66,15 @@ func (it *TrustIterator) Iterate(h reputation.TrustHandler) error {
 	// find out if local node is presented in netmap
 	localIndex := -1
 
-	for i := range nm.Nodes {
-		if bytes.Equal(nm.Nodes[i].PublicKey(), it.storage.LocalKey) {
+	nmNodes := nm.Nodes()
+	for i := range nmNodes {
+		if bytes.Equal(nmNodes[i].PublicKey(), it.storage.LocalKey) {
 			localIndex = i
 			break
 		}
 	}
 
-	ln := len(nm.Nodes)
+	ln := len(nmNodes)
 	if localIndex >= 0 && ln > 0 {
 		ln--
 	}
@@ -81,13 +82,13 @@ func (it *TrustIterator) Iterate(h reputation.TrustHandler) error {
 	// calculate Pj http://ilpubs.stanford.edu:8090/562/1/2002-56.pdf Chapter 4.5.
 	p := reputation.TrustOne.Div(reputation.TrustValueFromInt(ln))
 
-	for i := range nm.Nodes {
+	for i := range nmNodes {
 		if i == localIndex {
 			continue
 		}
 
 		trust := reputation.Trust{}
-		trust.SetPeer(reputation.PeerIDFromBytes(nm.Nodes[i].PublicKey()))
+		trust.SetPeer(reputation.PeerIDFromBytes(nmNodes[i].PublicKey()))
 		trust.SetValue(p)
 		trust.SetTrustingPeer(reputation.PeerIDFromBytes(it.storage.LocalKey))
 
diff --git a/go.mod b/go.mod
index e582d4826..1c9484efe 100644
--- a/go.mod
+++ b/go.mod
@@ -19,7 +19,7 @@ require (
 	github.com/nspcc-dev/neo-go/pkg/interop v0.0.0-20220601120906-3bec6657f5c5 // indirect
 	github.com/nspcc-dev/neofs-api-go/v2 v2.12.2
 	github.com/nspcc-dev/neofs-contract v0.15.1
-	github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.4.0.20220615085207-eb3b99081235
+	github.com/nspcc-dev/neofs-sdk-go v1.0.0-rc.4.0.20220616082321-e986f4780721
 	github.com/nspcc-dev/tzhash v1.5.2
 	github.com/panjf2000/ants/v2 v2.4.0
 	github.com/paulmach/orb v0.2.2
diff --git a/go.sum b/go.sum
index 9eb96d5984f404f36c01b7fc2859936e62f562d7..895a5b6716a6009f49697d1fdcd10c3b667b186d 100644
GIT binary patch
delta 111
zcmbQ&%r>u?ZG+-mXEOr}BV!{&-Be2pvosTP3j=c_Lxl`OD^tfD<CK(?B7<OeV}HMl
ywDg>i%48$=;Jm<KgEHUT%5-NJ1A{W3eEqD@$%50QCfCiC7r|!M=8bdTJ_Z0<*&`nS

delta 111
zcmbQ&%r>u?ZG+-mXHx?UQzHX&-P9!GBuh&J3qvDgQ-useE05eTgU}HF(&7N0DD6nM
y&~WV>pR|HRw``xVN+aLk&|<&x^n#GY2zTe?$%50QCfCiC7r|!M=8bdTJ_Z1L$0Nu9

diff --git a/pkg/core/container/fmt_test.go b/pkg/core/container/fmt_test.go
index 41d4d9eb8..65fc3d937 100644
--- a/pkg/core/container/fmt_test.go
+++ b/pkg/core/container/fmt_test.go
@@ -6,7 +6,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/nspcc-dev/neofs-node/pkg/util/test"
 	"github.com/nspcc-dev/neofs-sdk-go/container"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
+	netmaptest "github.com/nspcc-dev/neofs-sdk-go/netmap/test"
 	"github.com/nspcc-dev/neofs-sdk-go/user"
 	"github.com/nspcc-dev/neofs-sdk-go/version"
 	"github.com/stretchr/testify/require"
@@ -17,8 +17,8 @@ func TestCheckFormat(t *testing.T) {
 
 	require.Error(t, CheckFormat(c))
 
-	policy := netmap.NewPlacementPolicy()
-	c.SetPlacementPolicy(policy)
+	policy := netmaptest.PlacementPolicy()
+	c.SetPlacementPolicy(&policy)
 
 	require.Error(t, CheckFormat(c))
 
diff --git a/pkg/core/netmap/nodes.go b/pkg/core/netmap/nodes.go
new file mode 100644
index 000000000..3183a2cce
--- /dev/null
+++ b/pkg/core/netmap/nodes.go
@@ -0,0 +1,31 @@
+package netmap
+
+import "github.com/nspcc-dev/neofs-sdk-go/netmap"
+
+// Node is a named type of netmap.NodeInfo which provides interface needed
+// in the current repository. Node is expected to be used everywhere instead
+// of direct usage of netmap.NodeInfo, so it represents a type mediator.
+type Node netmap.NodeInfo
+
+// PublicKey returns public key bound to the storage node.
+//
+// Return value MUST NOT be mutated, make a copy first.
+func (x Node) PublicKey() []byte {
+	return (netmap.NodeInfo)(x).PublicKey()
+}
+
+// IterateAddresses iterates over all announced network addresses
+// and passes them into f. Handler MUST NOT be nil.
+func (x Node) IterateAddresses(f func(string) bool) {
+	(netmap.NodeInfo)(x).IterateNetworkEndpoints(f)
+}
+
+// NumberOfAddresses returns number of announced network addresses.
+func (x Node) NumberOfAddresses() int {
+	return (netmap.NodeInfo)(x).NumberOfNetworkEndpoints()
+}
+
+// Nodes is a named type of []netmap.NodeInfo which provides interface needed
+// in the current repository. Nodes is expected to be used everywhere instead
+// of direct usage of []netmap.NodeInfo, so it represents a type mediator.
+type Nodes []netmap.NodeInfo
diff --git a/pkg/core/netmap/storage.go b/pkg/core/netmap/storage.go
index 2ef469edc..8f72ce1fe 100644
--- a/pkg/core/netmap/storage.go
+++ b/pkg/core/netmap/storage.go
@@ -16,7 +16,7 @@ type Source interface {
 	//
 	// Implementations must not retain the network map pointer and modify
 	// the network map through it.
-	GetNetMap(diff uint64) (*netmap.Netmap, error)
+	GetNetMap(diff uint64) (*netmap.NetMap, error)
 
 	// GetNetMapByEpoch reads network map by the epoch number from the storage.
 	// It returns the pointer to the requested network map and any error encountered.
@@ -25,7 +25,7 @@ type Source interface {
 	//
 	// Implementations must not retain the network map pointer and modify
 	// the network map through it.
-	GetNetMapByEpoch(epoch uint64) (*netmap.Netmap, error)
+	GetNetMapByEpoch(epoch uint64) (*netmap.NetMap, error)
 
 	// Epoch reads the current epoch from the storage.
 	// It returns thw number of the current epoch and any error encountered.
@@ -35,11 +35,11 @@ type Source interface {
 }
 
 // GetLatestNetworkMap requests and returns the latest network map from the storage.
-func GetLatestNetworkMap(src Source) (*netmap.Netmap, error) {
+func GetLatestNetworkMap(src Source) (*netmap.NetMap, error) {
 	return src.GetNetMap(0)
 }
 
 // GetPreviousNetworkMap requests and returns previous from the latest network map from the storage.
-func GetPreviousNetworkMap(src Source) (*netmap.Netmap, error) {
+func GetPreviousNetworkMap(src Source) (*netmap.NetMap, error) {
 	return src.GetNetMap(1)
 }
diff --git a/pkg/innerring/processors/alphabet/process_emit.go b/pkg/innerring/processors/alphabet/process_emit.go
index 51ef9f584..a06defb3a 100644
--- a/pkg/innerring/processors/alphabet/process_emit.go
+++ b/pkg/innerring/processors/alphabet/process_emit.go
@@ -48,7 +48,9 @@ func (ap *Processor) processEmit() {
 		return
 	}
 
-	ln := len(networkMap.Nodes)
+	nmNodes := networkMap.Nodes()
+
+	ln := len(nmNodes)
 	if ln == 0 {
 		ap.log.Debug("empty network map, do not emit gas")
 
@@ -57,8 +59,8 @@ func (ap *Processor) processEmit() {
 
 	gasPerNode := fixedn.Fixed8(ap.storageEmission / uint64(ln))
 
-	for i := range networkMap.Nodes {
-		keyBytes := networkMap.Nodes[i].PublicKey()
+	for i := range nmNodes {
+		keyBytes := nmNodes[i].PublicKey()
 
 		key, err := keys.NewPublicKeyFromBytes(keyBytes, elliptic.P256())
 		if err != nil {
diff --git a/pkg/innerring/processors/audit/process.go b/pkg/innerring/processors/audit/process.go
index c542de2df..83c974b79 100644
--- a/pkg/innerring/processors/audit/process.go
+++ b/pkg/innerring/processors/audit/process.go
@@ -6,11 +6,12 @@ import (
 	"encoding/hex"
 
 	clientcore "github.com/nspcc-dev/neofs-node/pkg/core/client"
+	netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	cntClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
 	"github.com/nspcc-dev/neofs-node/pkg/services/audit"
+	"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/placement"
 	"github.com/nspcc-dev/neofs-node/pkg/util/rand"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	"go.uber.org/zap"
 )
@@ -59,10 +60,19 @@ func (ap *Processor) processStartAudit(epoch uint64) {
 			continue
 		}
 
+		policy := cnr.PlacementPolicy()
+		if policy == nil {
+			log.Error("missing placement policy in container, ignore",
+				zap.Stringer("cid", containers[i]),
+			)
+
+			continue
+		}
+
 		containers[i].Encode(pivot)
 
 		// find all container nodes for current epoch
-		nodes, err := nm.GetContainerNodes(cnr.PlacementPolicy(), pivot)
+		nodes, err := nm.ContainerNodes(*policy, pivot)
 		if err != nil {
 			log.Info("can't build placement for container, ignore",
 				zap.Stringer("cid", containers[i]),
@@ -71,7 +81,7 @@ func (ap *Processor) processStartAudit(epoch uint64) {
 			continue
 		}
 
-		n := nodes.Flatten()
+		n := placement.FlattenNodes(nodes)
 
 		// shuffle nodes to ask a random one
 		rand.Shuffle(len(n), func(i, j int) {
@@ -110,7 +120,7 @@ func (ap *Processor) processStartAudit(epoch uint64) {
 	}
 }
 
-func (ap *Processor) findStorageGroups(cnr cid.ID, shuffled netmap.Nodes) []oid.ID {
+func (ap *Processor) findStorageGroups(cnr cid.ID, shuffled netmapcore.Nodes) []oid.ID {
 	var sg []oid.ID
 
 	ln := len(shuffled)
@@ -130,7 +140,7 @@ func (ap *Processor) findStorageGroups(cnr cid.ID, shuffled netmap.Nodes) []oid.
 			zap.Int("total_tries", ln),
 		)
 
-		err := clientcore.NodeInfoFromRawNetmapElement(&info, shuffled[i])
+		err := clientcore.NodeInfoFromRawNetmapElement(&info, netmapcore.Node(shuffled[i]))
 		if err != nil {
 			log.Warn("parse client node info", zap.String("error", err.Error()))
 
diff --git a/pkg/innerring/processors/container/process_container.go b/pkg/innerring/processors/container/process_container.go
index d761f15d3..ff6bb34c6 100644
--- a/pkg/innerring/processors/container/process_container.go
+++ b/pkg/innerring/processors/container/process_container.go
@@ -240,10 +240,15 @@ func checkSubnet(subCli *morphsubnet.Client, cnr *containerSDK.Container) error
 		return errors.New("missing owner")
 	}
 
+	policy := cnr.PlacementPolicy()
+	if policy == nil {
+		return errors.New("missing placement policy")
+	}
+
 	prm := morphsubnet.UserAllowedPrm{}
 
-	subID := cnr.PlacementPolicy().SubnetID()
-	if subID == nil || subnetid.IsZero(*subID) {
+	subID := policy.Subnet()
+	if subnetid.IsZero(subID) {
 		return nil
 	}
 
@@ -256,7 +261,7 @@ func checkSubnet(subCli *morphsubnet.Client, cnr *containerSDK.Container) error
 	}
 
 	if !res.Allowed() {
-		return fmt.Errorf("user is not allowed to create containers in %s subnetwork", subID)
+		return fmt.Errorf("user is not allowed to create containers in %v subnetwork", subID)
 	}
 
 	return nil
diff --git a/pkg/innerring/processors/netmap/cleanup_table.go b/pkg/innerring/processors/netmap/cleanup_table.go
index 3049f1f67..f7af9977d 100644
--- a/pkg/innerring/processors/netmap/cleanup_table.go
+++ b/pkg/innerring/processors/netmap/cleanup_table.go
@@ -3,7 +3,6 @@ package netmap
 import (
 	"bytes"
 	"encoding/hex"
-	"fmt"
 	"sync"
 
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
@@ -39,20 +38,19 @@ func newCleanupTable(enabled bool, threshold uint64) cleanupTable {
 }
 
 // Update cleanup table based on on-chain information about netmap.
-func (c *cleanupTable) update(snapshot *netmap.Netmap, now uint64) {
+func (c *cleanupTable) update(snapshot netmap.NetMap, now uint64) {
 	c.Lock()
 	defer c.Unlock()
 
+	nmNodes := snapshot.Nodes()
+
 	// replacing map is less memory efficient but faster
-	newMap := make(map[string]epochStampWithNodeInfo, len(snapshot.Nodes))
+	newMap := make(map[string]epochStampWithNodeInfo, len(nmNodes))
 
-	for i := range snapshot.Nodes {
-		binNodeInfo, err := snapshot.Nodes[i].Marshal()
-		if err != nil {
-			panic(fmt.Errorf("could not marshal node info: %w", err)) // seems better than ignore
-		}
+	for i := range nmNodes {
+		binNodeInfo := nmNodes[i].Marshal()
 
-		keyString := hex.EncodeToString(snapshot.Nodes[i].PublicKey())
+		keyString := hex.EncodeToString(nmNodes[i].PublicKey())
 
 		access, ok := c.lastAccess[keyString]
 		if ok {
diff --git a/pkg/innerring/processors/netmap/cleanup_table_test.go b/pkg/innerring/processors/netmap/cleanup_table_test.go
index 773d0f2ac..a3f5062e5 100644
--- a/pkg/innerring/processors/netmap/cleanup_table_test.go
+++ b/pkg/innerring/processors/netmap/cleanup_table_test.go
@@ -22,14 +22,13 @@ func TestCleanupTable(t *testing.T) {
 		newNodeInfo(genKey(t).PublicKey()),
 	}
 
-	networkMap, err := netmap.NewNetmap(netmap.NodesFromInfo(infos))
-	require.NoError(t, err)
+	var networkMap netmap.NetMap
+	networkMap.SetNodes(infos)
 
 	mapInfos := make(map[string][]byte)
 
 	for i := range infos {
-		binNodeInfo, err := infos[i].Marshal()
-		require.NoError(t, err)
+		binNodeInfo := infos[i].Marshal()
 
 		mapInfos[hex.EncodeToString(infos[i].PublicKey())] = binNodeInfo
 	}
diff --git a/pkg/innerring/processors/netmap/nodevalidation/locode/calls.go b/pkg/innerring/processors/netmap/nodevalidation/locode/calls.go
index 1d386cc78..831792624 100644
--- a/pkg/innerring/processors/netmap/nodevalidation/locode/calls.go
+++ b/pkg/innerring/processors/netmap/nodevalidation/locode/calls.go
@@ -30,24 +30,12 @@ var errMissingRequiredAttr = errors.New("missing required attribute in DB record
 //
 // UN-LOCODE attribute remains untouched.
 func (v *Validator) VerifyAndUpdate(n *netmap.NodeInfo) error {
-	mAttr := uniqueAttributes(n.Attributes())
-
-	// check if the derived attributes are presented
-	for attrKey := range v.mAttr {
-		if _, ok := mAttr[attrKey]; ok {
-			return fmt.Errorf("attribute derived from %s is presented: %s",
-				netmap.AttrUNLOCODE,
-				attrKey,
-			)
-		}
-	}
-
-	attrLocode, ok := mAttr[netmap.AttrUNLOCODE]
-	if !ok {
+	attrLocode := n.LOCODE()
+	if attrLocode == "" {
 		return nil
 	}
 
-	lc, err := locode.FromString(attrLocode.Value())
+	lc, err := locode.FromString(attrLocode)
 	if err != nil {
 		return fmt.Errorf("invalid locode value: %w", err)
 	}
@@ -57,41 +45,48 @@ func (v *Validator) VerifyAndUpdate(n *netmap.NodeInfo) error {
 		return fmt.Errorf("could not get locode record from DB: %w", err)
 	}
 
-	for attrKey, attrDesc := range v.mAttr {
-		attrVal := attrDesc.converter(record)
-		if attrVal == "" {
-			if !attrDesc.optional {
-				return errMissingRequiredAttr
-			}
-
-			continue
-		}
-
-		var a netmap.NodeAttribute
-		a.SetKey(attrKey)
-		a.SetValue(attrVal)
-
-		mAttr[attrKey] = a
+	countryCode := record.CountryCode()
+	if countryCode == nil {
+		return errMissingRequiredAttr
 	}
 
-	as := n.Attributes()
-	as = as[:0]
-
-	for _, attr := range mAttr {
-		as = append(as, attr)
+	strCountryCode := countryCode.String()
+	if strCountryCode == "" {
+		return errMissingRequiredAttr
 	}
 
-	n.SetAttributes(as...)
+	countryName := record.CountryName()
+	if countryName == "" {
+		return errMissingRequiredAttr
+	}
+
+	locationName := record.LocationName()
+	if locationName == "" {
+		return errMissingRequiredAttr
+	}
+
+	continent := record.Continent()
+	if continent == nil {
+		return errMissingRequiredAttr
+	}
+
+	continentName := continent.String()
+	if continentName == "" {
+		return errMissingRequiredAttr
+	}
+
+	n.SetCountryCode(strCountryCode)
+	n.SetCountryName(countryName)
+	n.SetLocationName(locationName)
+	n.SetContinentName(continentName)
+
+	if subDivCode := record.SubDivCode(); subDivCode != "" {
+		n.SetSubdivisionCode(subDivCode)
+	}
+
+	if subDivName := record.SubDivName(); subDivName != "" {
+		n.SetSubdivisionName(subDivName)
+	}
 
 	return nil
 }
-
-func uniqueAttributes(as []netmap.NodeAttribute) map[string]netmap.NodeAttribute {
-	mAttr := make(map[string]netmap.NodeAttribute, len(as))
-
-	for _, attr := range as {
-		mAttr[attr.Key()] = attr
-	}
-
-	return mAttr
-}
diff --git a/pkg/innerring/processors/netmap/nodevalidation/locode/calls_test.go b/pkg/innerring/processors/netmap/nodevalidation/locode/calls_test.go
index 8d4d2fa30..ab17e34ba 100644
--- a/pkg/innerring/processors/netmap/nodevalidation/locode/calls_test.go
+++ b/pkg/innerring/processors/netmap/nodevalidation/locode/calls_test.go
@@ -34,40 +34,21 @@ func (x db) Get(lc *locodestd.LOCODE) (locode.Record, error) {
 	return r, nil
 }
 
-func addAttrKV(n *netmap.NodeInfo, key, val string) {
-	var a netmap.NodeAttribute
-
-	a.SetKey(key)
-	a.SetValue(val)
-
-	n.SetAttributes(append(n.Attributes(), a)...)
-}
-
 func addLocodeAttrValue(n *netmap.NodeInfo, val string) {
-	addAttrKV(n, netmap.AttrUNLOCODE, val)
+	n.SetLOCODE(val)
 }
 
 func addLocodeAttr(n *netmap.NodeInfo, lc locodestd.LOCODE) {
-	addLocodeAttrValue(n, fmt.Sprintf("%s %s", lc[0], lc[1]))
+	n.SetLOCODE(fmt.Sprintf("%s %s", lc[0], lc[1]))
 }
 
 func nodeInfoWithSomeAttrs() *netmap.NodeInfo {
-	n := netmap.NewNodeInfo()
+	var n netmap.NodeInfo
 
-	addAttrKV(n, "key1", "val1")
-	addAttrKV(n, "key2", "val2")
+	n.SetAttribute("key1", "val1")
+	n.SetAttribute("key2", "val2")
 
-	return n
-}
-
-func containsAttr(n *netmap.NodeInfo, key, val string) bool {
-	for _, a := range n.Attributes() {
-		if a.Key() == key && a.Value() == val {
-			return true
-		}
-	}
-
-	return false
+	return &n
 }
 
 func TestValidator_VerifyAndUpdate(t *testing.T) {
@@ -108,41 +89,11 @@ func TestValidator_VerifyAndUpdate(t *testing.T) {
 
 	validator := locode.New(p)
 
-	t.Run("w/ derived attributes", func(t *testing.T) {
-		fn := func(withLocode bool) {
-			for _, derivedAttr := range []string{
-				netmap.AttrCountryCode,
-				netmap.AttrCountry,
-				netmap.AttrLocation,
-				netmap.AttrSubDivCode,
-				netmap.AttrSubDiv,
-				netmap.AttrContinent,
-			} {
-				n := nodeInfoWithSomeAttrs()
-
-				addAttrKV(n, derivedAttr, "some value")
-
-				if withLocode {
-					addLocodeAttr(n, r.LOCODE)
-				}
-
-				err := validator.VerifyAndUpdate(n)
-				require.Error(t, err)
-			}
-		}
-
-		fn(true)
-		fn(false)
-	})
-
 	t.Run("w/o locode", func(t *testing.T) {
 		n := nodeInfoWithSomeAttrs()
 
-		attrs := n.Attributes()
-
 		err := validator.VerifyAndUpdate(n)
 		require.NoError(t, err)
-		require.Equal(t, attrs, n.Attributes())
 	})
 
 	t.Run("w/ locode", func(t *testing.T) {
@@ -168,22 +119,14 @@ func TestValidator_VerifyAndUpdate(t *testing.T) {
 
 		addLocodeAttr(n, r.LOCODE)
 
-		attrs := n.Attributes()
-
 		err := validator.VerifyAndUpdate(n)
 		require.NoError(t, err)
 
-		outAttrs := n.Attributes()
-
-		for _, a := range attrs {
-			require.Contains(t, outAttrs, a)
-		}
-
-		require.True(t, containsAttr(n, netmap.AttrCountryCode, rec.CountryCode().String()))
-		require.True(t, containsAttr(n, netmap.AttrCountry, rec.CountryName()))
-		require.True(t, containsAttr(n, netmap.AttrLocation, rec.LocationName()))
-		require.True(t, containsAttr(n, netmap.AttrSubDivCode, rec.SubDivCode()))
-		require.True(t, containsAttr(n, netmap.AttrSubDiv, rec.SubDivName()))
-		require.True(t, containsAttr(n, netmap.AttrContinent, rec.Continent().String()))
+		require.Equal(t, rec.CountryCode().String(), n.Attribute("CountryCode"))
+		require.Equal(t, rec.CountryName(), n.Attribute("Country"))
+		require.Equal(t, rec.LocationName(), n.Attribute("Location"))
+		require.Equal(t, rec.SubDivCode(), n.Attribute("SubDivCode"))
+		require.Equal(t, rec.SubDivName(), n.Attribute("SubDiv"))
+		require.Equal(t, rec.Continent().String(), n.Attribute("Continent"))
 	})
 }
diff --git a/pkg/innerring/processors/netmap/nodevalidation/locode/util.go b/pkg/innerring/processors/netmap/nodevalidation/locode/util.go
deleted file mode 100644
index efbff4d8a..000000000
--- a/pkg/innerring/processors/netmap/nodevalidation/locode/util.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package locode
-
-type attrDescriptor struct {
-	optional  bool
-	converter func(Record) string
-}
-
-func countryCodeValue(r Record) (val string) {
-	return r.CountryCode().String()
-}
-
-func countryValue(r Record) string {
-	return r.CountryName()
-}
-
-func locationValue(r Record) string {
-	return r.LocationName()
-}
-
-func subDivCodeValue(r Record) string {
-	return r.SubDivCode()
-}
-
-func subDivValue(r Record) string {
-	return r.SubDivName()
-}
-
-func continentValue(r Record) string {
-	return r.Continent().String()
-}
diff --git a/pkg/innerring/processors/netmap/nodevalidation/locode/validator.go b/pkg/innerring/processors/netmap/nodevalidation/locode/validator.go
index 38e47c81a..639eb1651 100644
--- a/pkg/innerring/processors/netmap/nodevalidation/locode/validator.go
+++ b/pkg/innerring/processors/netmap/nodevalidation/locode/validator.go
@@ -1,9 +1,5 @@
 package locode
 
-import (
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
-)
-
 // Prm groups the required parameters of the Validator's constructor.
 //
 // All values must comply with the requirements imposed on them.
@@ -26,8 +22,6 @@ type Prm struct {
 // the Validator is immediately ready to work through API.
 type Validator struct {
 	db DB
-
-	mAttr map[string]attrDescriptor
 }
 
 // New creates a new instance of the Validator.
@@ -39,16 +33,5 @@ type Validator struct {
 func New(prm Prm) *Validator {
 	return &Validator{
 		db: prm.DB,
-		mAttr: map[string]attrDescriptor{
-			netmap.AttrCountryCode: {converter: countryCodeValue},
-			netmap.AttrCountry:     {converter: countryValue},
-
-			netmap.AttrLocation: {converter: locationValue},
-
-			netmap.AttrSubDivCode: {converter: subDivCodeValue, optional: true},
-			netmap.AttrSubDiv:     {converter: subDivValue, optional: true},
-
-			netmap.AttrContinent: {converter: continentValue},
-		},
 	}
 }
diff --git a/pkg/innerring/processors/netmap/nodevalidation/maddress/calls.go b/pkg/innerring/processors/netmap/nodevalidation/maddress/calls.go
index 4067c83dc..fa6afbde7 100644
--- a/pkg/innerring/processors/netmap/nodevalidation/maddress/calls.go
+++ b/pkg/innerring/processors/netmap/nodevalidation/maddress/calls.go
@@ -9,7 +9,7 @@ import (
 
 // VerifyAndUpdate calls network.VerifyAddress.
 func (v *Validator) VerifyAndUpdate(n *netmap.NodeInfo) error {
-	err := network.VerifyMultiAddress(n)
+	err := network.VerifyMultiAddress(*n)
 	if err != nil {
 		return fmt.Errorf("could not verify multiaddress: %w", err)
 	}
diff --git a/pkg/innerring/processors/netmap/process_cleanup.go b/pkg/innerring/processors/netmap/process_cleanup.go
index fa29f0f6d..0aff66fc9 100644
--- a/pkg/innerring/processors/netmap/process_cleanup.go
+++ b/pkg/innerring/processors/netmap/process_cleanup.go
@@ -2,8 +2,8 @@ package netmap
 
 import (
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
+	v2netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap"
 	netmapclient "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 	"go.uber.org/zap"
 )
 
@@ -34,7 +34,6 @@ func (np *Processor) processNetmapCleanupTick(ev netmapCleanupTick) {
 			prm := netmapclient.UpdatePeerPrm{}
 
 			prm.SetKey(key.Bytes())
-			prm.SetState(netmap.NodeStateOffline)
 			prm.SetHash(ev.TxHash())
 
 			err = np.netmapClient.UpdatePeerState(prm)
@@ -45,7 +44,7 @@ func (np *Processor) processNetmapCleanupTick(ev netmapCleanupTick) {
 				uint32(ev.epoch),
 				nil,
 				methodUpdateStateNotary,
-				int64(netmap.NodeStateOffline.ToV2()), key.Bytes(),
+				int64(v2netmap.Offline), key.Bytes(),
 			)
 		}
 		if err != nil {
diff --git a/pkg/innerring/processors/netmap/process_epoch.go b/pkg/innerring/processors/netmap/process_epoch.go
index cf7633839..edd152c84 100644
--- a/pkg/innerring/processors/netmap/process_epoch.go
+++ b/pkg/innerring/processors/netmap/process_epoch.go
@@ -60,7 +60,7 @@ func (np *Processor) processNewEpoch(ev netmapEvent.NewEpoch) {
 		}
 	}
 
-	np.netmapSnapshot.update(networkMap, epoch)
+	np.netmapSnapshot.update(*networkMap, epoch)
 	np.handleCleanupTick(netmapCleanupTick{epoch: epoch, txHash: ev.TxHash()})
 	np.handleNewAudit(audit.NewAuditStartEvent(epoch))
 	np.handleAuditSettlements(settlement.NewAuditEvent(epoch))
diff --git a/pkg/innerring/processors/netmap/process_peers.go b/pkg/innerring/processors/netmap/process_peers.go
index 9edb87d51..c6849661d 100644
--- a/pkg/innerring/processors/netmap/process_peers.go
+++ b/pkg/innerring/processors/netmap/process_peers.go
@@ -3,8 +3,6 @@ package netmap
 import (
 	"bytes"
 	"encoding/hex"
-	"sort"
-	"strings"
 
 	netmapclient "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
 	netmapEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/netmap"
@@ -36,7 +34,7 @@ func (np *Processor) processAddPeer(ev netmapEvent.AddPeer) {
 	}
 
 	// unmarshal node info
-	nodeInfo := netmap.NewNodeInfo()
+	var nodeInfo netmap.NodeInfo
 	if err := nodeInfo.Unmarshal(ev.Node()); err != nil {
 		// it will be nice to have tx id at event structure to log it
 		np.log.Warn("can't parse network map candidate")
@@ -44,7 +42,7 @@ func (np *Processor) processAddPeer(ev netmapEvent.AddPeer) {
 	}
 
 	// validate and update node info
-	err := np.nodeValidator.VerifyAndUpdate(nodeInfo)
+	err := np.nodeValidator.VerifyAndUpdate(&nodeInfo)
 	if err != nil {
 		np.log.Warn("could not verify and update information about network map candidate",
 			zap.String("error", err.Error()),
@@ -54,28 +52,10 @@ func (np *Processor) processAddPeer(ev netmapEvent.AddPeer) {
 	}
 
 	// sort attributes to make it consistent
-	a := nodeInfo.Attributes()
-	sort.Slice(a, func(i, j int) bool {
-		switch strings.Compare(a[i].Key(), a[j].Key()) {
-		case -1:
-			return true
-		case 1:
-			return false
-		default:
-			return a[i].Value() < a[j].Value()
-		}
-	})
-	nodeInfo.SetAttributes(a...)
+	nodeInfo.SortAttributes()
 
 	// marshal updated node info structure
-	nodeInfoBinary, err := nodeInfo.Marshal()
-	if err != nil {
-		np.log.Warn("could not marshal updated network map candidate",
-			zap.String("error", err.Error()),
-		)
-
-		return
-	}
+	nodeInfoBinary := nodeInfo.Marshal()
 
 	keyString := hex.EncodeToString(nodeInfo.PublicKey())
 
@@ -121,15 +101,6 @@ func (np *Processor) processUpdatePeer(ev netmapEvent.UpdatePeer) {
 		return
 	}
 
-	// better use unified enum from neofs-api-go/v2/netmap package
-	if ev.Status() != netmap.NodeStateOffline {
-		np.log.Warn("node proposes unknown state",
-			zap.String("key", hex.EncodeToString(ev.PublicKey().Bytes())),
-			zap.Stringer("status", ev.Status()),
-		)
-		return
-	}
-
 	// flag node to remove from local view, so it can be re-bootstrapped
 	// again before new epoch will tick
 	np.netmapSnapshot.flag(hex.EncodeToString(ev.PublicKey().Bytes()))
@@ -141,7 +112,9 @@ func (np *Processor) processUpdatePeer(ev netmapEvent.UpdatePeer) {
 	} else {
 		prm := netmapclient.UpdatePeerPrm{}
 
-		prm.SetState(ev.Status())
+		if ev.Online() {
+			prm.SetOnline()
+		}
 		prm.SetKey(ev.PublicKey().Bytes())
 
 		err = np.netmapClient.UpdatePeerState(prm)
@@ -181,12 +154,14 @@ func (np *Processor) processRemoveSubnetNode(ev subnetEvent.RemoveNode) {
 		return
 	}
 
-	for _, node := range candidates.Nodes {
-		if !bytes.Equal(node.NodeInfo.PublicKey(), ev.Node()) {
+	candidateNodes := candidates.Nodes()
+
+	for i := range candidateNodes {
+		if !bytes.Equal(candidateNodes[i].PublicKey(), ev.Node()) {
 			continue
 		}
 
-		err = node.IterateSubnets(func(subNetID subnetid.ID) error {
+		err = candidateNodes[i].IterateSubnets(func(subNetID subnetid.ID) error {
 			if subNetID.Equals(subnetToRemoveFrom) {
 				return netmap.ErrRemoveSubnet
 			}
@@ -199,7 +174,6 @@ func (np *Processor) processRemoveSubnetNode(ev subnetEvent.RemoveNode) {
 
 			prm := netmapclient.UpdatePeerPrm{}
 			prm.SetKey(ev.Node())
-			prm.SetState(netmap.NodeStateOffline)
 			prm.SetHash(ev.TxHash())
 
 			err = np.netmapClient.UpdatePeerState(prm)
@@ -209,7 +183,7 @@ func (np *Processor) processRemoveSubnetNode(ev subnetEvent.RemoveNode) {
 			}
 		} else {
 			prm := netmapclient.AddPeerPrm{}
-			prm.SetNodeInfo(node.NodeInfo)
+			prm.SetNodeInfo(candidateNodes[i])
 			prm.SetHash(ev.TxHash())
 
 			err = np.netmapClient.AddPeer(prm)
diff --git a/pkg/innerring/rpc.go b/pkg/innerring/rpc.go
index b23e0e3d1..a612d25bd 100644
--- a/pkg/innerring/rpc.go
+++ b/pkg/innerring/rpc.go
@@ -7,6 +7,7 @@ import (
 	"time"
 
 	clientcore "github.com/nspcc-dev/neofs-node/pkg/core/client"
+	netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	neofsapiclient "github.com/nspcc-dev/neofs-node/pkg/innerring/internal/client"
 	auditproc "github.com/nspcc-dev/neofs-node/pkg/innerring/processors/audit"
 	"github.com/nspcc-dev/neofs-node/pkg/network/cache"
@@ -69,7 +70,7 @@ func (c *ClientCache) GetSG(task *audit.Task, id oid.ID) (*storagegroup.StorageG
 	return c.getSG(task.AuditContext(), sgAddress, task.NetworkMap(), task.ContainerNodes())
 }
 
-func (c *ClientCache) getSG(ctx context.Context, addr oid.Address, nm *netmap.Netmap, cn netmap.ContainerNodes) (*storagegroup.StorageGroup, error) {
+func (c *ClientCache) getSG(ctx context.Context, addr oid.Address, nm *netmap.NetMap, cn [][]netmap.NodeInfo) (*storagegroup.StorageGroup, error) {
 	obj := addr.Object()
 
 	nodes, err := placement.BuildObjectPlacement(nm, cn, &obj)
@@ -80,7 +81,7 @@ func (c *ClientCache) getSG(ctx context.Context, addr oid.Address, nm *netmap.Ne
 	var info clientcore.NodeInfo
 
 	for _, node := range placement.FlattenNodes(nodes) {
-		err := clientcore.NodeInfoFromRawNetmapElement(&info, node)
+		err := clientcore.NodeInfoFromRawNetmapElement(&info, netmapcore.Node(node))
 		if err != nil {
 			return nil, fmt.Errorf("parse client node info: %w", err)
 		}
@@ -124,14 +125,14 @@ func (c *ClientCache) getSG(ctx context.Context, addr oid.Address, nm *netmap.Ne
 }
 
 // GetHeader requests node from the container under audit to return object header by id.
-func (c *ClientCache) GetHeader(task *audit.Task, node *netmap.Node, id oid.ID, relay bool) (*object.Object, error) {
+func (c *ClientCache) GetHeader(task *audit.Task, node netmap.NodeInfo, id oid.ID, relay bool) (*object.Object, error) {
 	var objAddress oid.Address
 	objAddress.SetContainer(task.ContainerID())
 	objAddress.SetObject(id)
 
 	var info clientcore.NodeInfo
 
-	err := clientcore.NodeInfoFromRawNetmapElement(&info, node)
+	err := clientcore.NodeInfoFromRawNetmapElement(&info, netmapcore.Node(node))
 	if err != nil {
 		return nil, fmt.Errorf("parse client node info: %w", err)
 	}
@@ -162,14 +163,14 @@ func (c *ClientCache) GetHeader(task *audit.Task, node *netmap.Node, id oid.ID,
 
 // GetRangeHash requests node from the container under audit to return Tillich-Zemor hash of the
 // payload range of the object with specified identifier.
-func (c *ClientCache) GetRangeHash(task *audit.Task, node *netmap.Node, id oid.ID, rng *object.Range) ([]byte, error) {
+func (c *ClientCache) GetRangeHash(task *audit.Task, node netmap.NodeInfo, id oid.ID, rng *object.Range) ([]byte, error) {
 	var objAddress oid.Address
 	objAddress.SetContainer(task.ContainerID())
 	objAddress.SetObject(id)
 
 	var info clientcore.NodeInfo
 
-	err := clientcore.NodeInfoFromRawNetmapElement(&info, node)
+	err := clientcore.NodeInfoFromRawNetmapElement(&info, netmapcore.Node(node))
 	if err != nil {
 		return nil, fmt.Errorf("parse client node info: %w", err)
 	}
diff --git a/pkg/innerring/settlement.go b/pkg/innerring/settlement.go
index b7f01af52..dbb6a8503 100644
--- a/pkg/innerring/settlement.go
+++ b/pkg/innerring/settlement.go
@@ -6,6 +6,7 @@ import (
 	"crypto/elliptic"
 	"crypto/sha256"
 	"encoding/hex"
+	"errors"
 	"fmt"
 	"math/big"
 
@@ -18,6 +19,7 @@ import (
 	auditClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/audit"
 	balanceClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/balance"
 	containerClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
+	"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/placement"
 	"github.com/nspcc-dev/neofs-node/pkg/util/logger"
 	auditAPI "github.com/nspcc-dev/neofs-sdk-go/audit"
 	containerAPI "github.com/nspcc-dev/neofs-sdk-go/container"
@@ -75,7 +77,7 @@ type auditSettlementCalculator audit.Calculator
 type containerWrapper containerAPI.Container
 
 type nodeInfoWrapper struct {
-	ni *netmapAPI.Node
+	ni netmapAPI.NodeInfo
 }
 
 type sgWrapper storagegroup.StorageGroup
@@ -89,7 +91,7 @@ func (n nodeInfoWrapper) PublicKey() []byte {
 }
 
 func (n nodeInfoWrapper) Price() *big.Int {
-	return big.NewInt(int64(n.ni.Price))
+	return big.NewInt(int64(n.ni.Price()))
 }
 
 func (c *containerWrapper) Owner() user.ID {
@@ -125,9 +127,9 @@ func (s settlementDeps) ContainerInfo(cid cid.ID) (common.ContainerInfo, error)
 	return (*containerWrapper)(cnr), nil
 }
 
-func (s settlementDeps) buildContainer(e uint64, cid cid.ID) (netmapAPI.ContainerNodes, *netmapAPI.Netmap, error) {
+func (s settlementDeps) buildContainer(e uint64, cid cid.ID) ([][]netmapAPI.NodeInfo, *netmapAPI.NetMap, error) {
 	var (
-		nm  *netmapAPI.Netmap
+		nm  *netmapAPI.NetMap
 		err error
 	)
 
@@ -146,11 +148,16 @@ func (s settlementDeps) buildContainer(e uint64, cid cid.ID) (netmapAPI.Containe
 		return nil, nil, fmt.Errorf("could not get container from sidechain: %w", err)
 	}
 
+	policy := cnr.PlacementPolicy()
+	if policy == nil {
+		return nil, nil, errors.New("missing placement policy in container")
+	}
+
 	binCnr := make([]byte, sha256.Size)
 	cid.Encode(binCnr)
 
-	cn, err := nm.GetContainerNodes(
-		cnr.PlacementPolicy(),
+	cn, err := nm.ContainerNodes(
+		*policy,
 		binCnr, // may be replace pivot calculation to neofs-api-go
 	)
 	if err != nil {
@@ -166,12 +173,12 @@ func (s settlementDeps) ContainerNodes(e uint64, cid cid.ID) ([]common.NodeInfo,
 		return nil, err
 	}
 
-	ns := cn.Flatten()
+	ns := placement.FlattenNodes(cn)
 	res := make([]common.NodeInfo, 0, len(ns))
 
 	for i := range ns {
 		res = append(res, &nodeInfoWrapper{
-			ni: &ns[i],
+			ni: ns[i],
 		})
 	}
 
diff --git a/pkg/innerring/subnet.go b/pkg/innerring/subnet.go
index f60d736a0..0e49a25fa 100644
--- a/pkg/innerring/subnet.go
+++ b/pkg/innerring/subnet.go
@@ -301,19 +301,21 @@ func (s *Server) handleSubnetRemoval(e event.Event) {
 		return
 	}
 
-	for _, c := range candidates.Nodes {
-		s.processCandidate(delEv.TxHash(), removedID, c)
+	candidateNodes := candidates.Nodes()
+
+	for i := range candidateNodes {
+		s.processCandidate(delEv.TxHash(), removedID, candidateNodes[i])
 	}
 }
 
-func (s *Server) processCandidate(txHash neogoutil.Uint256, removedID subnetid.ID, c netmap.Node) {
+func (s *Server) processCandidate(txHash neogoutil.Uint256, removedID subnetid.ID, c netmap.NodeInfo) {
 	removeSubnet := false
 	log := s.log.With(
-		zap.String("public_key", hex.EncodeToString(c.NodeInfo.PublicKey())),
+		zap.String("public_key", hex.EncodeToString(c.PublicKey())),
 		zap.String("removed_subnet", removedID.String()),
 	)
 
-	err := c.NodeInfo.IterateSubnets(func(id subnetid.ID) error {
+	err := c.IterateSubnets(func(id subnetid.ID) error {
 		if removedID.Equals(id) {
 			removeSubnet = true
 			return netmap.ErrRemoveSubnet
@@ -326,8 +328,7 @@ func (s *Server) processCandidate(txHash neogoutil.Uint256, removedID subnetid.I
 		log.Debug("removing node from netmap candidates")
 
 		var updateStatePrm netmapclient.UpdatePeerPrm
-		updateStatePrm.SetState(netmap.NodeStateOffline)
-		updateStatePrm.SetKey(c.NodeInfo.PublicKey())
+		updateStatePrm.SetKey(c.PublicKey())
 		updateStatePrm.SetHash(txHash)
 
 		err = s.netmapClient.UpdatePeerState(updateStatePrm)
@@ -346,7 +347,7 @@ func (s *Server) processCandidate(txHash neogoutil.Uint256, removedID subnetid.I
 		log.Debug("removing subnet from the node")
 
 		var addPeerPrm netmapclient.AddPeerPrm
-		addPeerPrm.SetNodeInfo(c.NodeInfo)
+		addPeerPrm.SetNodeInfo(c)
 		addPeerPrm.SetHash(txHash)
 
 		err = s.netmapClient.AddPeer(addPeerPrm)
diff --git a/pkg/morph/client/netmap/add_peer.go b/pkg/morph/client/netmap/add_peer.go
index b5736a9df..d42fab2b1 100644
--- a/pkg/morph/client/netmap/add_peer.go
+++ b/pkg/morph/client/netmap/add_peer.go
@@ -9,13 +9,13 @@ import (
 
 // AddPeerPrm groups parameters of AddPeer operation.
 type AddPeerPrm struct {
-	nodeInfo *netmap.NodeInfo
+	nodeInfo netmap.NodeInfo
 
 	client.InvokePrmOptional
 }
 
 // SetNodeInfo sets new peer NodeInfo.
-func (a *AddPeerPrm) SetNodeInfo(nodeInfo *netmap.NodeInfo) {
+func (a *AddPeerPrm) SetNodeInfo(nodeInfo netmap.NodeInfo) {
 	a.nodeInfo = nodeInfo
 }
 
@@ -31,18 +31,9 @@ func (c *Client) AddPeer(p AddPeerPrm) error {
 		method += "IR"
 	}
 
-	if p.nodeInfo == nil {
-		return fmt.Errorf("nil node info (%s)", method)
-	}
-
-	rawNodeInfo, err := p.nodeInfo.Marshal()
-	if err != nil {
-		return fmt.Errorf("can't marshal node info (%s): %w", method, err)
-	}
-
 	prm := client.InvokePrm{}
 	prm.SetMethod(method)
-	prm.SetArgs(rawNodeInfo)
+	prm.SetArgs(p.nodeInfo.Marshal())
 	prm.InvokePrmOptional = p.InvokePrmOptional
 
 	if err := c.client.Invoke(prm); err != nil {
diff --git a/pkg/morph/client/netmap/config.go b/pkg/morph/client/netmap/config.go
index 501142635..77cf95b65 100644
--- a/pkg/morph/client/netmap/config.go
+++ b/pkg/morph/client/netmap/config.go
@@ -185,85 +185,112 @@ func (c *Client) SetConfig(p SetConfigPrm) error {
 	return c.client.Invoke(prm)
 }
 
-// IterateConfigParameters iterates over configuration parameters stored in Netmap contract and passes them to f.
-//
-// Returns f's errors directly.
-func (c *Client) IterateConfigParameters(f func(key, value []byte) error) error {
+// RawNetworkParameter is a NeoFS network parameter which is transmitted but
+// not interpreted by the NeoFS API protocol.
+type RawNetworkParameter struct {
+	// Name of the parameter.
+	Name string
+
+	// Raw parameter value.
+	Value []byte
+}
+
+// NetworkConfiguration represents NeoFS network configuration stored
+// in the NeoFS Sidechain.
+type NetworkConfiguration struct {
+	MaxObjectSize uint64
+
+	StoragePrice uint64
+
+	AuditFee uint64
+
+	EpochDuration uint64
+
+	ContainerFee uint64
+
+	ContainerAliasFee uint64
+
+	EigenTrustIterations uint64
+
+	EigenTrustAlpha float64
+
+	IRCandidateFee uint64
+
+	WithdrawalFee uint64
+
+	Raw []RawNetworkParameter
+}
+
+// ReadNetworkConfiguration reads NetworkConfiguration from the NeoFS Sidechain.
+func (c *Client) ReadNetworkConfiguration() (*NetworkConfiguration, error) {
 	prm := client.TestInvokePrm{}
 	prm.SetMethod(configListMethod)
 
 	items, err := c.client.TestInvoke(prm)
 	if err != nil {
-		return fmt.Errorf("could not perform test invocation (%s): %w",
+		return nil, fmt.Errorf("could not perform test invocation (%s): %w",
 			configListMethod, err)
 	}
 
 	if ln := len(items); ln != 1 {
-		return fmt.Errorf("unexpected stack item count (%s): %d", configListMethod, ln)
+		return nil, fmt.Errorf("unexpected stack item count (%s): %d", configListMethod, ln)
 	}
 
 	arr, err := client.ArrayFromStackItem(items[0])
 	if err != nil {
-		return fmt.Errorf("record list (%s): %w", configListMethod, err)
+		return nil, fmt.Errorf("record list (%s): %w", configListMethod, err)
 	}
 
-	return iterateRecords(arr, func(key, value []byte) error {
-		return f(key, value)
-	})
-}
+	m := make(map[string]struct{}, len(arr))
+	var res NetworkConfiguration
+	res.Raw = make([]RawNetworkParameter, 0, len(arr))
 
-// ConfigWriter is an interface of NeoFS network config writer.
-type ConfigWriter interface {
-	UnknownParameter(string, []byte)
-	MaxObjectSize(uint64)
-	BasicIncomeRate(uint64)
-	AuditFee(uint64)
-	EpochDuration(uint64)
-	ContainerFee(uint64)
-	ContainerAliasFee(uint64)
-	EigenTrustIterations(uint64)
-	EigenTrustAlpha(float64)
-	InnerRingCandidateFee(uint64)
-	WithdrawFee(uint64)
-}
+	err = iterateRecords(arr, func(name string, value []byte) error {
+		_, ok := m[name]
+		if ok {
+			return fmt.Errorf("duplicated config name %s", name)
+		}
 
-// WriteConfig writes NeoFS network configuration received via iterator.
-//
-// Returns iterator's errors directly.
-func WriteConfig(dst ConfigWriter, iterator func(func(key, val []byte) error) error) error {
-	return iterator(func(key, val []byte) error {
-		switch k := string(key); k {
+		m[name] = struct{}{}
+
+		switch name {
 		default:
-			dst.UnknownParameter(k, val)
+			res.Raw = append(res.Raw, RawNetworkParameter{
+				Name:  name,
+				Value: value,
+			})
 		case maxObjectSizeConfig:
-			dst.MaxObjectSize(bytesToUint64(val))
+			res.MaxObjectSize = bytesToUint64(value)
 		case basicIncomeRateConfig:
-			dst.BasicIncomeRate(bytesToUint64(val))
+			res.StoragePrice = bytesToUint64(value)
 		case auditFeeConfig:
-			dst.AuditFee(bytesToUint64(val))
+			res.AuditFee = bytesToUint64(value)
 		case epochDurationConfig:
-			dst.EpochDuration(bytesToUint64(val))
+			res.EpochDuration = bytesToUint64(value)
 		case containerFeeConfig:
-			dst.ContainerFee(bytesToUint64(val))
+			res.ContainerFee = bytesToUint64(value)
 		case containerAliasFeeConfig:
-			dst.ContainerAliasFee(bytesToUint64(val))
+			res.ContainerAliasFee = bytesToUint64(value)
 		case etIterationsConfig:
-			dst.EigenTrustIterations(bytesToUint64(val))
+			res.EigenTrustIterations = bytesToUint64(value)
 		case etAlphaConfig:
-			v, err := strconv.ParseFloat(string(val), 64)
+			res.EigenTrustAlpha, err = strconv.ParseFloat(string(value), 64)
 			if err != nil {
-				return fmt.Errorf("prm %s: %v", etAlphaConfig, err)
+				return fmt.Errorf("invalid prm %s: %v", etAlphaConfig, err)
 			}
-
-			dst.EigenTrustAlpha(v)
 		case irCandidateFeeConfig:
-			dst.InnerRingCandidateFee(bytesToUint64(val))
+			res.IRCandidateFee = bytesToUint64(value)
 		case withdrawFeeConfig:
-			dst.WithdrawFee(bytesToUint64(val))
+			res.WithdrawalFee = bytesToUint64(value)
 		}
 
 		return nil
 	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &res, nil
 }
 
 func bytesToUint64(val []byte) uint64 {
@@ -307,7 +334,7 @@ func StringAssert(item stackitem.Item) (interface{}, error) {
 // iterateRecords iterates over all config records and passes them to f.
 //
 // Returns f's errors directly.
-func iterateRecords(arr []stackitem.Item, f func(key, value []byte) error) error {
+func iterateRecords(arr []stackitem.Item, f func(key string, value []byte) error) error {
 	for i := range arr {
 		fields, err := client.ArrayFromStackItem(arr[i])
 		if err != nil {
@@ -328,7 +355,7 @@ func iterateRecords(arr []stackitem.Item, f func(key, value []byte) error) error
 			return fmt.Errorf("record value: %w", err)
 		}
 
-		if err := f(k, v); err != nil {
+		if err := f(string(k), v); err != nil {
 			return err
 		}
 	}
diff --git a/pkg/morph/client/netmap/netmap.go b/pkg/morph/client/netmap/netmap.go
index 0af7e22c1..d099f680d 100644
--- a/pkg/morph/client/netmap/netmap.go
+++ b/pkg/morph/client/netmap/netmap.go
@@ -8,20 +8,6 @@ import (
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 )
 
-// State is an enumeration of various states of the NeoFS node.
-type State int64
-
-const (
-	// Undefined is unknown state.
-	Undefined State = iota
-
-	// Online is network unavailable state.
-	Online
-
-	// Offline is an active state in the network.
-	Offline
-)
-
 const (
 	nodeInfoFixedPrmNumber = 1
 
@@ -31,7 +17,7 @@ const (
 // GetNetMapByEpoch receives information list about storage nodes
 // through the Netmap contract call, composes network map
 // from them and returns it. Returns snapshot of the specified epoch number.
-func (c *Client) GetNetMapByEpoch(epoch uint64) (*netmap.Netmap, error) {
+func (c *Client) GetNetMapByEpoch(epoch uint64) (*netmap.NetMap, error) {
 	invokePrm := client.TestInvokePrm{}
 	invokePrm.SetMethod(epochSnapshotMethod)
 	invokePrm.SetArgs(epoch)
@@ -48,7 +34,7 @@ func (c *Client) GetNetMapByEpoch(epoch uint64) (*netmap.Netmap, error) {
 // GetCandidates receives information list about candidates
 // for the next epoch network map through the Netmap contract
 // call, composes network map from them and returns it.
-func (c *Client) GetCandidates() (*netmap.Netmap, error) {
+func (c *Client) GetCandidates() (*netmap.NetMap, error) {
 	invokePrm := client.TestInvokePrm{}
 	invokePrm.SetMethod(netMapCandidatesMethod)
 
@@ -62,7 +48,10 @@ func (c *Client) GetCandidates() (*netmap.Netmap, error) {
 		return nil, fmt.Errorf("could not parse contract response: %w", err)
 	}
 
-	return netmap.NewNetmap(netmap.NodesFromInfo(candVals))
+	var nm netmap.NetMap
+	nm.SetNodes(candVals)
+
+	return &nm, nil
 }
 
 // NetMap performs the test invoke of get network map
@@ -128,11 +117,9 @@ func stackItemToNodeInfo(prm stackitem.Item, res *netmap.NodeInfo) error {
 
 	switch state {
 	case 1:
-		res.SetState(netmap.NodeStateOnline)
+		res.SetOnline()
 	case 2:
-		res.SetState(netmap.NodeStateOffline)
-	default:
-		res.SetState(0)
+		res.SetOffline()
 	}
 
 	return nil
diff --git a/pkg/morph/client/netmap/netmap_test.go b/pkg/morph/client/netmap/netmap_test.go
index 3b6a43937..bb38e207a 100644
--- a/pkg/morph/client/netmap/netmap_test.go
+++ b/pkg/morph/client/netmap/netmap_test.go
@@ -17,23 +17,29 @@ func Test_stackItemsToNodeInfos(t *testing.T) {
 		pub := make([]byte, 33)
 		rand.Read(pub)
 
-		expected[i].SetState(netmap.NodeState(i % 3))
+		switch i % 3 {
+		case 1:
+			expected[i].SetOffline()
+		case 2:
+			expected[i].SetOnline()
+		}
+
 		expected[i].SetPublicKey(pub)
 
-		var attr netmap.NodeAttribute
-		attr.SetKey("key")
-		attr.SetValue(strconv.Itoa(i))
-		expected[i].SetAttributes(attr)
+		expected[i].SetAttribute("key", strconv.Itoa(i))
 	}
 
 	items := make([]stackitem.Item, 4)
 	for i := range items {
-		data, err := expected[i].Marshal()
-		require.NoError(t, err)
+		data := expected[i].Marshal()
 
-		state := int64(expected[i].State())
-		if state != 0 { // In contract online=1, offline=2, in API it is the other way.
-			state = 3 - state
+		var state int64
+
+		switch {
+		case expected[i].IsOnline():
+			state = 1
+		case expected[i].IsOffline():
+			state = 2
 		}
 
 		items[i] = stackitem.NewStruct([]stackitem.Item{
diff --git a/pkg/morph/client/netmap/snapshot.go b/pkg/morph/client/netmap/snapshot.go
index 0f6df2868..5eaed9a3e 100644
--- a/pkg/morph/client/netmap/snapshot.go
+++ b/pkg/morph/client/netmap/snapshot.go
@@ -12,17 +12,17 @@ import (
 // through the Netmap contract call, composes network map
 // from them and returns it. With diff == 0 returns current
 // network map, else return snapshot of previous network map.
-func (c *Client) GetNetMap(diff uint64) (*netmap.Netmap, error) {
+func (c *Client) GetNetMap(diff uint64) (*netmap.NetMap, error) {
 	return c.getNetMap(diff)
 }
 
 // Snapshot returns current netmap node infos.
 // Consider using pkg/morph/client/netmap for this.
-func (c *Client) Snapshot() (*netmap.Netmap, error) {
+func (c *Client) Snapshot() (*netmap.NetMap, error) {
 	return c.getNetMap(0)
 }
 
-func (c *Client) getNetMap(diff uint64) (*netmap.Netmap, error) {
+func (c *Client) getNetMap(diff uint64) (*netmap.NetMap, error) {
 	prm := client.TestInvokePrm{}
 	prm.SetMethod(snapshotMethod)
 	prm.SetArgs(diff)
@@ -35,7 +35,7 @@ func (c *Client) getNetMap(diff uint64) (*netmap.Netmap, error) {
 	return unmarshalNetmap(res, snapshotMethod)
 }
 
-func unmarshalNetmap(items []stackitem.Item, method string) (*netmap.Netmap, error) {
+func unmarshalNetmap(items []stackitem.Item, method string) (*netmap.NetMap, error) {
 	rawPeers, err := peersFromStackItems(items, method)
 	if err != nil {
 		return nil, err
@@ -48,5 +48,8 @@ func unmarshalNetmap(items []stackitem.Item, method string) (*netmap.Netmap, err
 		}
 	}
 
-	return netmap.NewNetmap(netmap.NodesFromInfo(result))
+	var nm netmap.NetMap
+	nm.SetNodes(result)
+
+	return &nm, nil
 }
diff --git a/pkg/morph/client/netmap/update_state.go b/pkg/morph/client/netmap/update_state.go
index 9bd83f7ff..e6c8cca71 100644
--- a/pkg/morph/client/netmap/update_state.go
+++ b/pkg/morph/client/netmap/update_state.go
@@ -4,13 +4,13 @@ import (
 	"fmt"
 
 	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 )
 
 // UpdatePeerPrm groups parameters of UpdatePeerState operation.
 type UpdatePeerPrm struct {
-	key   []byte
-	state netmap.NodeState
+	key []byte
+
+	online bool
 
 	client.InvokePrmOptional
 }
@@ -21,8 +21,8 @@ func (u *UpdatePeerPrm) SetKey(key []byte) {
 }
 
 // SetState sets node state.
-func (u *UpdatePeerPrm) SetState(state netmap.NodeState) {
-	u.state = state
+func (u *UpdatePeerPrm) SetOnline() {
+	u.online = true
 }
 
 // UpdatePeerState changes peer status through Netmap contract call.
@@ -36,9 +36,14 @@ func (c *Client) UpdatePeerState(p UpdatePeerPrm) error {
 		method += "IR"
 	}
 
+	state := 2
+	if p.online {
+		state = 1
+	}
+
 	prm := client.InvokePrm{}
 	prm.SetMethod(method)
-	prm.SetArgs(int64(p.state.ToV2()), p.key)
+	prm.SetArgs(int64(state), p.key)
 	prm.InvokePrmOptional = p.InvokePrmOptional
 
 	if err := c.client.Invoke(prm); err != nil {
diff --git a/pkg/morph/event/netmap/update_peer.go b/pkg/morph/event/netmap/update_peer.go
index 40911b5e7..e7fd5fcfd 100644
--- a/pkg/morph/event/netmap/update_peer.go
+++ b/pkg/morph/event/netmap/update_peer.go
@@ -10,12 +10,12 @@ import (
 	v2netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 )
 
 type UpdatePeer struct {
 	publicKey *keys.PublicKey
-	status    netmap.NodeState
+
+	online bool
 
 	// For notary notifications only.
 	// Contains raw transactions of notary request.
@@ -25,8 +25,8 @@ type UpdatePeer struct {
 // MorphEvent implements Neo:Morph Event interface.
 func (UpdatePeer) MorphEvent() {}
 
-func (s UpdatePeer) Status() netmap.NodeState {
-	return s.status
+func (s UpdatePeer) Online() bool {
+	return s.online
 }
 
 func (s UpdatePeer) PublicKey() *keys.PublicKey {
@@ -73,7 +73,13 @@ func ParseUpdatePeer(e *subscriptions.NotificationEvent) (event.Event, error) {
 		return nil, fmt.Errorf("could not get node status: %w", err)
 	}
 
-	ev.status = netmap.NodeStateFromV2(v2netmap.NodeState(st))
+	switch v2netmap.NodeState(st) {
+	default:
+		return nil, fmt.Errorf("unsupported node state %d", st)
+	case v2netmap.Offline:
+	case v2netmap.Online:
+		ev.online = true
+	}
 
 	return ev, nil
 }
diff --git a/pkg/morph/event/netmap/update_peer_notary.go b/pkg/morph/event/netmap/update_peer_notary.go
index 0738bbfd4..8dc22bfc5 100644
--- a/pkg/morph/event/netmap/update_peer_notary.go
+++ b/pkg/morph/event/netmap/update_peer_notary.go
@@ -7,9 +7,8 @@ import (
 
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
 	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
-	netmapv2 "github.com/nspcc-dev/neofs-api-go/v2/netmap"
+	v2netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 )
 
 var errNilPubKey = errors.New("could not parse public key: public key is nil")
@@ -27,10 +26,6 @@ func (s *UpdatePeer) setPublicKey(v []byte) (err error) {
 	return
 }
 
-func (s *UpdatePeer) setStatus(v uint32) {
-	s.status = netmap.NodeStateFromV2(netmapv2.NodeState(v))
-}
-
 const (
 	// UpdateStateNotaryEvent is method name for netmap state updating
 	// operations in `Netmap` contract. Is used as identificator for
@@ -66,7 +61,13 @@ func ParseUpdatePeerNotary(ne event.NotaryEvent) (event.Event, error) {
 				return nil, err
 			}
 
-			ev.setStatus(uint32(state))
+			switch v2netmap.NodeState(state) {
+			default:
+				return nil, fmt.Errorf("unsupported node state %d", err)
+			case v2netmap.Offline:
+			case v2netmap.Online:
+				ev.online = true
+			}
 
 			fieldNum++
 		case fieldNum == expectedItemNumUpdatePeer:
diff --git a/pkg/morph/event/netmap/update_peer_test.go b/pkg/morph/event/netmap/update_peer_test.go
index 0ee4072f9..aa397be7e 100644
--- a/pkg/morph/event/netmap/update_peer_test.go
+++ b/pkg/morph/event/netmap/update_peer_test.go
@@ -7,7 +7,6 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
-	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 	"github.com/stretchr/testify/require"
 )
 
@@ -15,10 +14,7 @@ func TestParseUpdatePeer(t *testing.T) {
 	priv, err := keys.NewPrivateKey()
 	require.NoError(t, err)
 
-	var (
-		publicKey = priv.PublicKey()
-		state     = netmap.NodeStateOffline
-	)
+	publicKey := priv.PublicKey()
 
 	t.Run("wrong number of parameters", func(t *testing.T) {
 		prms := []stackitem.Item{
@@ -48,14 +44,14 @@ func TestParseUpdatePeer(t *testing.T) {
 
 	t.Run("correct behavior", func(t *testing.T) {
 		ev, err := ParseUpdatePeer(createNotifyEventFromItems([]stackitem.Item{
-			stackitem.NewBigInteger(new(big.Int).SetInt64(int64(state.ToV2()))),
+			stackitem.NewBigInteger(new(big.Int).SetInt64(1)),
 			stackitem.NewByteArray(publicKey.Bytes()),
 		}))
 		require.NoError(t, err)
 
 		require.Equal(t, UpdatePeer{
 			publicKey: publicKey,
-			status:    state,
+			online:    true,
 		}, ev)
 	})
 }
diff --git a/pkg/network/group.go b/pkg/network/group.go
index 113fd0c3b..e57c59748 100644
--- a/pkg/network/group.go
+++ b/pkg/network/group.go
@@ -132,10 +132,11 @@ func WriteToNodeInfo(g AddressGroup, ni *netmap.NodeInfo) {
 	addrs := make([]string, 0, num)
 
 	iterateAllAddresses(g, func(addr Address) {
+		ni.SetNetworkEndpoints()
 		addrs = append(addrs, addr.String())
 	})
 
-	ni.SetAddresses(addrs...)
+	ni.SetNetworkEndpoints(addrs...)
 }
 
 // Intersects checks if two AddressGroup have
diff --git a/pkg/network/validation.go b/pkg/network/validation.go
index 3d2013737..061baf247 100644
--- a/pkg/network/validation.go
+++ b/pkg/network/validation.go
@@ -30,6 +30,18 @@ var (
 	errUnsupportedPresentationProtocol = errors.New("unsupported presentation protocol in multiaddress")
 )
 
+// NodeEndpointsIterator is a wrapper over netmap.NodeInfo which implements
+// MultiAddressIterator.
+type NodeEndpointsIterator netmap.NodeInfo
+
+func (x NodeEndpointsIterator) IterateAddresses(f func(string) bool) {
+	(netmap.NodeInfo)(x).IterateNetworkEndpoints(f)
+}
+
+func (x NodeEndpointsIterator) NumberOfAddresses() int {
+	return (netmap.NodeInfo)(x).NumberOfNetworkEndpoints()
+}
+
 // VerifyMultiAddress validates multiaddress of n.
 //
 // If n's address contains more than 3 protocols
@@ -45,8 +57,8 @@ var (
 //    2. tcp
 //    3. tls(optional, may be absent)
 //
-func VerifyMultiAddress(ni *netmap.NodeInfo) error {
-	return iterateParsedAddresses(ni, checkProtocols)
+func VerifyMultiAddress(ni netmap.NodeInfo) error {
+	return iterateParsedAddresses(NodeEndpointsIterator(ni), checkProtocols)
 }
 
 func checkProtocols(a Address) error {
diff --git a/pkg/network/validation_test.go b/pkg/network/validation_test.go
index b44d10cc6..0c3859668 100644
--- a/pkg/network/validation_test.go
+++ b/pkg/network/validation_test.go
@@ -55,10 +55,7 @@ func TestVerifyMultiAddress_Order(t *testing.T) {
 	}
 }
 
-func constructNodeInfo(address string) *netmap.NodeInfo {
-	ni := new(netmap.NodeInfo)
-
-	ni.SetAddresses(address)
-
+func constructNodeInfo(address string) (ni netmap.NodeInfo) {
+	ni.SetNetworkEndpoints(address)
 	return ni
 }
diff --git a/pkg/services/audit/auditor/context.go b/pkg/services/audit/auditor/context.go
index ef0816f78..5d296c011 100644
--- a/pkg/services/audit/auditor/context.go
+++ b/pkg/services/audit/auditor/context.go
@@ -29,7 +29,7 @@ type Context struct {
 	sgMembersCache map[int][]oid.ID
 
 	placementMtx   sync.Mutex
-	placementCache map[string][]netmap.Nodes
+	placementCache map[string][][]netmap.NodeInfo
 
 	porRequests, porRetries atomic.Uint32
 
@@ -51,11 +51,11 @@ type Context struct {
 type pairMemberInfo struct {
 	failedPDP, passedPDP bool // at least one
 
-	node *netmap.Node
+	node netmap.NodeInfo
 }
 
 type gamePair struct {
-	n1, n2 *netmap.Node
+	n1, n2 netmap.NodeInfo
 
 	id oid.ID
 
@@ -88,11 +88,11 @@ type ContainerCommunicator interface {
 	GetSG(*audit.Task, oid.ID) (*storagegroup.StorageGroup, error)
 
 	// Must return object header from the container node.
-	GetHeader(*audit.Task, *netmap.Node, oid.ID, bool) (*object.Object, error)
+	GetHeader(*audit.Task, netmap.NodeInfo, oid.ID, bool) (*object.Object, error)
 
 	// Must return homomorphic Tillich-Zemor hash of payload range of the
 	// object stored in container node.
-	GetRangeHash(*audit.Task, *netmap.Node, oid.ID, *object.Range) ([]byte, error)
+	GetRangeHash(*audit.Task, netmap.NodeInfo, oid.ID, *object.Range) ([]byte, error)
 }
 
 // NewContext creates, initializes and returns Context.
@@ -160,9 +160,12 @@ func (c *Context) init() {
 
 	c.sgMembersCache = make(map[int][]oid.ID)
 
-	c.placementCache = make(map[string][]netmap.Nodes)
+	c.placementCache = make(map[string][][]netmap.NodeInfo)
 
-	c.cnrNodesNum = len(c.task.ContainerNodes().Flatten())
+	cnrVectors := c.task.ContainerNodes()
+	for i := range cnrVectors {
+		c.cnrNodesNum += len(cnrVectors[i])
+	}
 
 	c.pairedNodes = make(map[uint64]*pairMemberInfo)
 
@@ -200,7 +203,7 @@ func (c *Context) writeReport() {
 	}
 }
 
-func (c *Context) buildPlacement(id oid.ID) ([]netmap.Nodes, error) {
+func (c *Context) buildPlacement(id oid.ID) ([][]netmap.NodeInfo, error) {
 	c.placementMtx.Lock()
 	defer c.placementMtx.Unlock()
 
diff --git a/pkg/services/audit/auditor/pdp.go b/pkg/services/audit/auditor/pdp.go
index 22ffb1a07..afec36c24 100644
--- a/pkg/services/audit/auditor/pdp.go
+++ b/pkg/services/audit/auditor/pdp.go
@@ -108,7 +108,7 @@ func (c *Context) splitPayload(id oid.ID) []uint64 {
 }
 
 func (c *Context) collectHashes(p *gamePair) {
-	fn := func(n *netmap.Node, rngs []*object.Range) [][]byte {
+	fn := func(n netmap.NodeInfo, rngs []*object.Range) [][]byte {
 		// Here we randomize the order a bit: the hypothesis is that this
 		// makes it harder for an unscrupulous node to come up with a
 		// reliable cheating strategy.
@@ -176,7 +176,7 @@ func (c *Context) analyzeHashes(p *gamePair) {
 	c.passNodesPDP(p.n1, p.n2)
 }
 
-func (c *Context) failNodesPDP(ns ...*netmap.Node) {
+func (c *Context) failNodesPDP(ns ...netmap.NodeInfo) {
 	c.pairedMtx.Lock()
 
 	for i := range ns {
@@ -186,7 +186,7 @@ func (c *Context) failNodesPDP(ns ...*netmap.Node) {
 	c.pairedMtx.Unlock()
 }
 
-func (c *Context) passNodesPDP(ns ...*netmap.Node) {
+func (c *Context) passNodesPDP(ns ...netmap.NodeInfo) {
 	c.pairedMtx.Lock()
 
 	for i := range ns {
@@ -200,18 +200,18 @@ func (c *Context) writePairsResult() {
 	var failCount, okCount int
 
 	c.iteratePairedNodes(
-		func(*netmap.Node) { failCount++ },
-		func(*netmap.Node) { okCount++ },
+		func(netmap.NodeInfo) { failCount++ },
+		func(netmap.NodeInfo) { okCount++ },
 	)
 
 	failedNodes := make([][]byte, 0, failCount)
 	passedNodes := make([][]byte, 0, okCount)
 
 	c.iteratePairedNodes(
-		func(n *netmap.Node) {
+		func(n netmap.NodeInfo) {
 			failedNodes = append(failedNodes, n.PublicKey())
 		},
-		func(n *netmap.Node) {
+		func(n netmap.NodeInfo) {
 			passedNodes = append(passedNodes, n.PublicKey())
 		},
 	)
@@ -219,7 +219,7 @@ func (c *Context) writePairsResult() {
 	c.report.SetPDPResults(passedNodes, failedNodes)
 }
 
-func (c *Context) iteratePairedNodes(onFail, onPass func(*netmap.Node)) {
+func (c *Context) iteratePairedNodes(onFail, onPass func(netmap.NodeInfo)) {
 	for _, pairedNode := range c.pairedNodes {
 		if pairedNode.failedPDP {
 			onFail(pairedNode.node)
diff --git a/pkg/services/audit/auditor/pop.go b/pkg/services/audit/auditor/pop.go
index c9dbc3725..bc7d36894 100644
--- a/pkg/services/audit/auditor/pop.go
+++ b/pkg/services/audit/auditor/pop.go
@@ -23,12 +23,12 @@ func (c *Context) executePoP() {
 }
 
 func (c *Context) buildCoverage() {
-	replicas := c.task.ContainerStructure().PlacementPolicy().Replicas()
+	policy := c.task.ContainerStructure().PlacementPolicy()
 
 	// select random member from another storage group
 	// and process all placement vectors
-	c.iterateSGMembersPlacementRand(func(id oid.ID, ind int, nodes netmap.Nodes) bool {
-		c.processObjectPlacement(id, nodes, replicas[ind].Count())
+	c.iterateSGMembersPlacementRand(func(id oid.ID, ind int, nodes []netmap.NodeInfo) bool {
+		c.processObjectPlacement(id, nodes, policy.ReplicaNumberByIndex(ind))
 		return c.containerCovered()
 	})
 }
@@ -38,7 +38,7 @@ func (c *Context) containerCovered() bool {
 	return c.cnrNodesNum <= len(c.pairedNodes)
 }
 
-func (c *Context) processObjectPlacement(id oid.ID, nodes netmap.Nodes, replicas uint32) {
+func (c *Context) processObjectPlacement(id oid.ID, nodes []netmap.NodeInfo, replicas uint32) {
 	var (
 		ok      uint32
 		optimal bool
@@ -50,7 +50,7 @@ func (c *Context) processObjectPlacement(id oid.ID, nodes netmap.Nodes, replicas
 
 	for i := 0; ok < replicas && i < len(nodes); i++ {
 		// try to get object header from node
-		hdr, err := c.cnrCom.GetHeader(c.task, &nodes[i], id, false)
+		hdr, err := c.cnrCom.GetHeader(c.task, nodes[i], id, false)
 		if err != nil {
 			c.log.Debug("could not get object header from candidate",
 				zap.Stringer("id", id),
@@ -95,14 +95,14 @@ func (c *Context) processObjectPlacement(id oid.ID, nodes netmap.Nodes, replicas
 
 	if unpairedCandidate1 >= 0 {
 		if unpairedCandidate2 >= 0 {
-			c.composePair(id, &nodes[unpairedCandidate1], &nodes[unpairedCandidate2])
+			c.composePair(id, nodes[unpairedCandidate1], nodes[unpairedCandidate2])
 		} else if pairedCandidate >= 0 {
-			c.composePair(id, &nodes[unpairedCandidate1], &nodes[pairedCandidate])
+			c.composePair(id, nodes[unpairedCandidate1], nodes[pairedCandidate])
 		}
 	}
 }
 
-func (c *Context) composePair(id oid.ID, n1, n2 *netmap.Node) {
+func (c *Context) composePair(id oid.ID, n1, n2 netmap.NodeInfo) {
 	c.pairs = append(c.pairs, gamePair{
 		n1: n1,
 		n2: n2,
@@ -117,7 +117,7 @@ func (c *Context) composePair(id oid.ID, n1, n2 *netmap.Node) {
 	}
 }
 
-func (c *Context) iterateSGMembersPlacementRand(f func(oid.ID, int, netmap.Nodes) bool) {
+func (c *Context) iterateSGMembersPlacementRand(f func(oid.ID, int, []netmap.NodeInfo) bool) {
 	// iterate over storage groups members for all storage groups (one by one)
 	// with randomly shuffled members
 	c.iterateSGMembersRand(func(id oid.ID) bool {
diff --git a/pkg/services/audit/auditor/por.go b/pkg/services/audit/auditor/por.go
index 1a4c183d9..7b9c1a8ca 100644
--- a/pkg/services/audit/auditor/por.go
+++ b/pkg/services/audit/auditor/por.go
@@ -78,7 +78,7 @@ func (c *Context) checkStorageGroupPoR(ind int, sg oid.ID) {
 				accRetries++
 			}
 
-			hdr, err := c.cnrCom.GetHeader(c.task, &flat[j], members[i], true)
+			hdr, err := c.cnrCom.GetHeader(c.task, flat[j], members[i], true)
 			if err != nil {
 				c.log.Debug("can't head object",
 					zap.String("remote_node", hex.EncodeToString(flat[j].PublicKey())),
diff --git a/pkg/services/audit/task.go b/pkg/services/audit/task.go
index 93ec3a89a..737a0a12c 100644
--- a/pkg/services/audit/task.go
+++ b/pkg/services/audit/task.go
@@ -19,9 +19,9 @@ type Task struct {
 
 	cnr *container.Container
 
-	nm *netmap.Netmap
+	nm *netmap.NetMap
 
-	cnrNodes netmap.ContainerNodes
+	cnrNodes [][]netmap.NodeInfo
 
 	sgList []oid.ID
 }
@@ -83,7 +83,7 @@ func (t *Task) ContainerStructure() *container.Container {
 }
 
 // WithContainerNodes sets nodes in the container under audit.
-func (t *Task) WithContainerNodes(cnrNodes netmap.ContainerNodes) *Task {
+func (t *Task) WithContainerNodes(cnrNodes [][]netmap.NodeInfo) *Task {
 	if t != nil {
 		t.cnrNodes = cnrNodes
 	}
@@ -92,12 +92,12 @@ func (t *Task) WithContainerNodes(cnrNodes netmap.ContainerNodes) *Task {
 }
 
 // NetworkMap returns network map of audit epoch.
-func (t *Task) NetworkMap() *netmap.Netmap {
+func (t *Task) NetworkMap() *netmap.NetMap {
 	return t.nm
 }
 
 // WithNetworkMap sets network map of audit epoch.
-func (t *Task) WithNetworkMap(nm *netmap.Netmap) *Task {
+func (t *Task) WithNetworkMap(nm *netmap.NetMap) *Task {
 	if t != nil {
 		t.nm = nm
 	}
@@ -106,7 +106,7 @@ func (t *Task) WithNetworkMap(nm *netmap.Netmap) *Task {
 }
 
 // ContainerNodes returns nodes in the container under audit.
-func (t *Task) ContainerNodes() netmap.ContainerNodes {
+func (t *Task) ContainerNodes() [][]netmap.NodeInfo {
 	return t.cnrNodes
 }
 
diff --git a/pkg/services/container/announcement/load/route/placement/calls.go b/pkg/services/container/announcement/load/route/placement/calls.go
index f33bc3be1..2e81a32aa 100644
--- a/pkg/services/container/announcement/load/route/placement/calls.go
+++ b/pkg/services/container/announcement/load/route/placement/calls.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 
+	netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	loadroute "github.com/nspcc-dev/neofs-node/pkg/services/container/announcement/load/route"
 	"github.com/nspcc-dev/neofs-sdk-go/container"
 )
@@ -37,14 +38,12 @@ func (b *Builder) NextStage(a container.UsedSpaceAnnouncement, passed []loadrout
 			continue
 		}
 
-		target := placement[i][0]
-
-		if len(passed) == 1 && bytes.Equal(passed[0].PublicKey(), target.PublicKey()) {
+		if len(passed) == 1 && bytes.Equal(passed[0].PublicKey(), placement[i][0].PublicKey()) {
 			// add nil element so the announcement will be saved in local memory
 			res = append(res, nil)
 		} else {
 			// add element with remote node to send announcement to
-			res = append(res, target)
+			res = append(res, netmapcore.Node(placement[i][0]))
 		}
 	}
 
diff --git a/pkg/services/container/announcement/load/route/placement/deps.go b/pkg/services/container/announcement/load/route/placement/deps.go
index 53ebc9bd5..0a4527cd9 100644
--- a/pkg/services/container/announcement/load/route/placement/deps.go
+++ b/pkg/services/container/announcement/load/route/placement/deps.go
@@ -10,5 +10,5 @@ type PlacementBuilder interface {
 	// BuildPlacement must compose and sort (according to a specific algorithm)
 	// storage nodes from the container by its identifier using network map
 	// of particular epoch.
-	BuildPlacement(epoch uint64, cnr cid.ID) ([]netmap.Nodes, error)
+	BuildPlacement(epoch uint64, cnr cid.ID) ([][]netmap.NodeInfo, error)
 }
diff --git a/pkg/services/control/server/netmap_snapshot.go b/pkg/services/control/server/netmap_snapshot.go
index 29b31a5d6..d9fcfd529 100644
--- a/pkg/services/control/server/netmap_snapshot.go
+++ b/pkg/services/control/server/netmap_snapshot.go
@@ -29,7 +29,7 @@ func (s *Server) NetmapSnapshot(ctx context.Context, req *control.NetmapSnapshot
 
 	nm := new(control.Netmap)
 	nm.SetEpoch(epoch)
-	nm.SetNodes(nodesFromAPI(apiNetMap.Nodes))
+	nm.SetNodes(nodesFromAPI(apiNetMap.Nodes()))
 
 	// create and fill response
 	resp := new(control.NetmapSnapshotResponse)
@@ -47,20 +47,28 @@ func (s *Server) NetmapSnapshot(ctx context.Context, req *control.NetmapSnapshot
 	return resp, nil
 }
 
-func nodesFromAPI(apiNodes netmapAPI.Nodes) []*control.NodeInfo {
+func nodesFromAPI(apiNodes []netmapAPI.NodeInfo) []*control.NodeInfo {
 	nodes := make([]*control.NodeInfo, 0, len(apiNodes))
 
-	for _, apiNode := range apiNodes {
+	for i := range apiNodes {
 		node := new(control.NodeInfo)
-		node.SetPublicKey(apiNode.PublicKey())
+		node.SetPublicKey(apiNodes[i].PublicKey())
 
-		addrs := make([]string, 0, apiNode.NumberOfAddresses())
-		netmapAPI.IterateAllAddresses(apiNode.NodeInfo, func(s string) {
+		addrs := make([]string, 0, apiNodes[i].NumberOfNetworkEndpoints())
+		netmapAPI.IterateNetworkEndpoints(apiNodes[i], func(s string) {
 			addrs = append(addrs, s)
 		})
 		node.SetAddresses(addrs)
-		node.SetAttributes(attributesFromAPI(apiNode.Attributes()))
-		node.SetState(stateFromAPI(apiNode.State()))
+		node.SetAttributes(attributesFromAPI(apiNodes[i]))
+
+		switch {
+		default:
+			node.SetState(control.NetmapStatus_STATUS_UNDEFINED)
+		case apiNodes[i].IsOnline():
+			node.SetState(control.NetmapStatus_ONLINE)
+		case apiNodes[i].IsOffline():
+			node.SetState(control.NetmapStatus_OFFLINE)
+		}
 
 		nodes = append(nodes, node)
 	}
@@ -68,36 +76,16 @@ func nodesFromAPI(apiNodes netmapAPI.Nodes) []*control.NodeInfo {
 	return nodes
 }
 
-func stateFromAPI(s netmapAPI.NodeState) control.NetmapStatus {
-	switch s {
-	default:
-		return control.NetmapStatus_STATUS_UNDEFINED
-	case netmapAPI.NodeStateOffline:
-		return control.NetmapStatus_OFFLINE
-	case netmapAPI.NodeStateOnline:
-		return control.NetmapStatus_ONLINE
-	}
-}
+func attributesFromAPI(apiNode netmapAPI.NodeInfo) []*control.NodeInfo_Attribute {
+	attrs := make([]*control.NodeInfo_Attribute, 0, apiNode.NumberOfAttributes())
 
-func attributesFromAPI(apiAttrs []netmapAPI.NodeAttribute) []*control.NodeInfo_Attribute {
-	attrs := make([]*control.NodeInfo_Attribute, 0, len(apiAttrs))
-
-	for _, apiAttr := range apiAttrs {
+	apiNode.IterateAttributes(func(key, value string) {
 		a := new(control.NodeInfo_Attribute)
-		a.SetKey(apiAttr.Key())
-		a.SetValue(apiAttr.Value())
-
-		apiParents := apiAttr.ParentKeys()
-		parents := make([]string, 0, len(apiParents))
-
-		for i := range apiParents {
-			parents = append(parents, apiParents[i])
-		}
-
-		a.SetParents(parents)
+		a.SetKey(key)
+		a.SetValue(value)
 
 		attrs = append(attrs, a)
-	}
+	})
 
 	return attrs
 }
diff --git a/pkg/services/netmap/executor.go b/pkg/services/netmap/executor.go
index 5a2ebca57..132556bb8 100644
--- a/pkg/services/netmap/executor.go
+++ b/pkg/services/netmap/executor.go
@@ -7,6 +7,7 @@ import (
 	"github.com/nspcc-dev/neofs-api-go/v2/netmap"
 	"github.com/nspcc-dev/neofs-api-go/v2/refs"
 	"github.com/nspcc-dev/neofs-node/pkg/core/version"
+	netmapSDK "github.com/nspcc-dev/neofs-sdk-go/netmap"
 	versionsdk "github.com/nspcc-dev/neofs-sdk-go/version"
 )
 
@@ -32,7 +33,7 @@ type NetworkInfo interface {
 	// Must return recent network information in NeoFS API v2 NetworkInfo structure.
 	//
 	// If protocol version is <=2.9, MillisecondsPerBlock and network config should be unset.
-	Dump(*refs.Version) (*netmap.NetworkInfo, error)
+	Dump(versionsdk.Version) (*netmapSDK.NetworkInfo, error)
 }
 
 func NewExecutionService(s NodeState, v versionsdk.Version, netInfo NetworkInfo) Server {
@@ -93,13 +94,24 @@ func (s *executorSvc) LocalNodeInfo(
 func (s *executorSvc) NetworkInfo(
 	_ context.Context,
 	req *netmap.NetworkInfoRequest) (*netmap.NetworkInfoResponse, error) {
-	ni, err := s.netInfo.Dump(req.GetMetaHeader().GetVersion())
+	verV2 := req.GetMetaHeader().GetVersion()
+	if verV2 == nil {
+		return nil, errors.New("missing protocol version in meta header")
+	}
+
+	var ver versionsdk.Version
+	ver.ReadFromV2(*verV2)
+
+	ni, err := s.netInfo.Dump(ver)
 	if err != nil {
 		return nil, err
 	}
 
+	var niV2 netmap.NetworkInfo
+	ni.WriteToV2(&niV2)
+
 	body := new(netmap.NetworkInfoResponseBody)
-	body.SetNetworkInfo(ni)
+	body.SetNetworkInfo(&niV2)
 
 	resp := new(netmap.NetworkInfoResponse)
 	resp.SetBody(body)
diff --git a/pkg/services/object/acl/v2/classifier.go b/pkg/services/object/acl/v2/classifier.go
index d5ece10ab..13d114f8a 100644
--- a/pkg/services/object/acl/v2/classifier.go
+++ b/pkg/services/object/acl/v2/classifier.go
@@ -132,18 +132,24 @@ func (c senderClassifier) isContainerKey(
 }
 
 func lookupKeyInContainer(
-	nm *netmap.Netmap,
+	nm *netmap.NetMap,
 	owner, idCnr []byte,
 	cnr *container.Container) (bool, error) {
-	cnrNodes, err := nm.GetContainerNodes(cnr.PlacementPolicy(), idCnr)
+	policy := cnr.PlacementPolicy()
+	if policy == nil {
+		return false, errors.New("missing placement policy in container")
+	}
+
+	cnrVectors, err := nm.ContainerNodes(*policy, idCnr)
 	if err != nil {
 		return false, err
 	}
 
-	flatCnrNodes := cnrNodes.Flatten() // we need single array to iterate on
-	for i := range flatCnrNodes {
-		if bytes.Equal(flatCnrNodes[i].PublicKey(), owner) {
-			return true, nil
+	for i := range cnrVectors {
+		for j := range cnrVectors[i] {
+			if bytes.Equal(cnrVectors[i][j].PublicKey(), owner) {
+				return true, nil
+			}
 		}
 	}
 
diff --git a/pkg/services/object/get/get_test.go b/pkg/services/object/get/get_test.go
index e34b679d0..aad3686ec 100644
--- a/pkg/services/object/get/get_test.go
+++ b/pkg/services/object/get/get_test.go
@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/nspcc-dev/neofs-node/pkg/core/client"
+	netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/core/object"
 	"github.com/nspcc-dev/neofs-node/pkg/network"
 	"github.com/nspcc-dev/neofs-node/pkg/services/object/util"
@@ -18,6 +19,7 @@ import (
 	"github.com/nspcc-dev/neofs-sdk-go/container"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
+	netmaptest "github.com/nspcc-dev/neofs-sdk-go/netmap/test"
 	objectSDK "github.com/nspcc-dev/neofs-sdk-go/object"
 	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
 	oidtest "github.com/nspcc-dev/neofs-sdk-go/object/id/test"
@@ -38,7 +40,7 @@ type testTraverserGenerator struct {
 }
 
 type testPlacementBuilder struct {
-	vectors map[string][]netmap.Nodes
+	vectors map[string][][]netmap.NodeInfo
 }
 
 type testClientCache struct {
@@ -81,7 +83,7 @@ func (g *testTraverserGenerator) GenerateTraverser(cnr cid.ID, obj *oid.ID, e ui
 	return placement.NewTraverser(opts...)
 }
 
-func (p *testPlacementBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, _ *netmap.PlacementPolicy) ([]netmap.Nodes, error) {
+func (p *testPlacementBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, _ netmap.PlacementPolicy) ([][]netmap.NodeInfo, error) {
 	var addr oid.Address
 	addr.SetContainer(cnr)
 
@@ -392,8 +394,8 @@ func TestGetLocalOnly(t *testing.T) {
 	})
 }
 
-func testNodeMatrix(t testing.TB, dim []int) ([]netmap.Nodes, [][]string) {
-	mNodes := make([]netmap.Nodes, len(dim))
+func testNodeMatrix(t testing.TB, dim []int) ([][]netmap.NodeInfo, [][]string) {
+	mNodes := make([][]netmap.NodeInfo, len(dim))
 	mAddr := make([][]string, len(dim))
 
 	for i := range dim {
@@ -406,20 +408,20 @@ func testNodeMatrix(t testing.TB, dim []int) ([]netmap.Nodes, [][]string) {
 				strconv.Itoa(60000+j),
 			)
 
-			ni := netmap.NewNodeInfo()
-			ni.SetAddresses(a)
+			var ni netmap.NodeInfo
+			ni.SetNetworkEndpoints(a)
 
 			var na network.AddressGroup
 
-			err := na.FromIterator(ni)
+			err := na.FromIterator(netmapcore.Node(ni))
 			require.NoError(t, err)
 
 			as[j] = network.StringifyGroup(na)
 
-			ns[j] = *ni
+			ns[j] = ni
 		}
 
-		mNodes[i] = netmap.NodesFromInfo(ns)
+		mNodes[i] = ns
 		mAddr[i] = as
 	}
 
@@ -464,7 +466,8 @@ func generateChain(ln int, cnr cid.ID) ([]*objectSDK.Object, []oid.ID, []byte) {
 func TestGetRemoteSmall(t *testing.T) {
 	ctx := context.Background()
 
-	cnr := container.New(container.WithPolicy(new(netmap.PlacementPolicy)))
+	pp := netmaptest.PlacementPolicy()
+	cnr := container.New(container.WithPolicy(&pp))
 	idCnr := container.CalculateID(cnr)
 
 	newSvc := func(b *testPlacementBuilder, c *testClientCache) *Service {
@@ -527,7 +530,7 @@ func TestGetRemoteSmall(t *testing.T) {
 		ns, as := testNodeMatrix(t, []int{2})
 
 		builder := &testPlacementBuilder{
-			vectors: map[string][]netmap.Nodes{
+			vectors: map[string][][]netmap.NodeInfo{
 				addr.EncodeToString(): ns,
 			},
 		}
@@ -590,7 +593,7 @@ func TestGetRemoteSmall(t *testing.T) {
 		ns, as := testNodeMatrix(t, []int{2})
 
 		builder := &testPlacementBuilder{
-			vectors: map[string][]netmap.Nodes{
+			vectors: map[string][][]netmap.NodeInfo{
 				addr.EncodeToString(): ns,
 			},
 		}
@@ -634,7 +637,7 @@ func TestGetRemoteSmall(t *testing.T) {
 		ns, as := testNodeMatrix(t, []int{2})
 
 		builder := &testPlacementBuilder{
-			vectors: map[string][]netmap.Nodes{
+			vectors: map[string][][]netmap.NodeInfo{
 				addr.EncodeToString(): ns,
 			},
 		}
@@ -708,7 +711,7 @@ func TestGetRemoteSmall(t *testing.T) {
 				c2.addResult(splitAddr, nil, apistatus.ObjectNotFound{})
 
 				builder := &testPlacementBuilder{
-					vectors: map[string][]netmap.Nodes{
+					vectors: map[string][][]netmap.NodeInfo{
 						addr.EncodeToString():      ns,
 						splitAddr.EncodeToString(): ns,
 					},
@@ -781,7 +784,7 @@ func TestGetRemoteSmall(t *testing.T) {
 				c2.addResult(child2Addr, nil, apistatus.ObjectNotFound{})
 
 				builder := &testPlacementBuilder{
-					vectors: map[string][]netmap.Nodes{
+					vectors: map[string][][]netmap.NodeInfo{
 						addr.EncodeToString():       ns,
 						linkAddr.EncodeToString():   ns,
 						child1Addr.EncodeToString(): ns,
@@ -858,7 +861,7 @@ func TestGetRemoteSmall(t *testing.T) {
 				c2.addResult(child2Addr, children[1], nil)
 
 				builder := &testPlacementBuilder{
-					vectors: map[string][]netmap.Nodes{
+					vectors: map[string][][]netmap.NodeInfo{
 						addr.EncodeToString():       ns,
 						linkAddr.EncodeToString():   ns,
 						child1Addr.EncodeToString(): ns,
@@ -924,7 +927,7 @@ func TestGetRemoteSmall(t *testing.T) {
 				c2.addResult(splitAddr, nil, apistatus.ObjectNotFound{})
 
 				builder := &testPlacementBuilder{
-					vectors: map[string][]netmap.Nodes{
+					vectors: map[string][][]netmap.NodeInfo{
 						addr.EncodeToString():      ns,
 						splitAddr.EncodeToString(): ns,
 					},
@@ -988,7 +991,7 @@ func TestGetRemoteSmall(t *testing.T) {
 				c2.addResult(rightAddr, rightObj, nil)
 
 				builder := &testPlacementBuilder{
-					vectors: map[string][]netmap.Nodes{
+					vectors: map[string][][]netmap.NodeInfo{
 						addr.EncodeToString():         ns,
 						rightAddr.EncodeToString():    ns,
 						preRightAddr.EncodeToString(): ns,
@@ -1058,7 +1061,7 @@ func TestGetRemoteSmall(t *testing.T) {
 				}
 
 				builder := &testPlacementBuilder{
-					vectors: map[string][]netmap.Nodes{},
+					vectors: map[string][][]netmap.NodeInfo{},
 				}
 
 				builder.vectors[addr.EncodeToString()] = ns
@@ -1116,7 +1119,8 @@ func TestGetRemoteSmall(t *testing.T) {
 func TestGetFromPastEpoch(t *testing.T) {
 	ctx := context.Background()
 
-	cnr := container.New(container.WithPolicy(new(netmap.PlacementPolicy)))
+	pp := netmaptest.PlacementPolicy()
+	cnr := container.New(container.WithPolicy(&pp))
 	idCnr := container.CalculateID(cnr)
 
 	addr := oidtest.Address()
@@ -1153,12 +1157,12 @@ func TestGetFromPastEpoch(t *testing.T) {
 		c: cnr,
 		b: map[uint64]placement.Builder{
 			curEpoch: &testPlacementBuilder{
-				vectors: map[string][]netmap.Nodes{
+				vectors: map[string][][]netmap.NodeInfo{
 					addr.EncodeToString(): ns[:1],
 				},
 			},
 			curEpoch - 1: &testPlacementBuilder{
-				vectors: map[string][]netmap.Nodes{
+				vectors: map[string][][]netmap.NodeInfo{
 					addr.EncodeToString(): ns[1:],
 				},
 			},
diff --git a/pkg/services/object/head/remote.go b/pkg/services/object/head/remote.go
index 50ed1190b..4854ad658 100644
--- a/pkg/services/object/head/remote.go
+++ b/pkg/services/object/head/remote.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	clientcore "github.com/nspcc-dev/neofs-node/pkg/core/client"
+	netmapCore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	internalclient "github.com/nspcc-dev/neofs-node/pkg/services/object/internal/client"
 	"github.com/nspcc-dev/neofs-node/pkg/services/object/util"
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
@@ -29,7 +30,7 @@ type RemoteHeader struct {
 type RemoteHeadPrm struct {
 	commonHeadPrm *Prm
 
-	node *netmap.NodeInfo
+	node netmap.NodeInfo
 }
 
 const remoteOpTTL = 1
@@ -45,7 +46,7 @@ func NewRemoteHeader(keyStorage *util.KeyStorage, cache ClientConstructor) *Remo
 }
 
 // WithNodeInfo sets information about the remote node.
-func (p *RemoteHeadPrm) WithNodeInfo(v *netmap.NodeInfo) *RemoteHeadPrm {
+func (p *RemoteHeadPrm) WithNodeInfo(v netmap.NodeInfo) *RemoteHeadPrm {
 	if p != nil {
 		p.node = v
 	}
@@ -71,7 +72,7 @@ func (h *RemoteHeader) Head(ctx context.Context, prm *RemoteHeadPrm) (*object.Ob
 
 	var info clientcore.NodeInfo
 
-	err = clientcore.NodeInfoFromRawNetmapElement(&info, prm.node)
+	err = clientcore.NodeInfoFromRawNetmapElement(&info, netmapCore.Node(prm.node))
 	if err != nil {
 		return nil, fmt.Errorf("parse client node info: %w", err)
 	}
diff --git a/pkg/services/object/put/remote.go b/pkg/services/object/put/remote.go
index e76ab3a1e..5a6273f68 100644
--- a/pkg/services/object/put/remote.go
+++ b/pkg/services/object/put/remote.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	clientcore "github.com/nspcc-dev/neofs-node/pkg/core/client"
+	netmapCore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	internalclient "github.com/nspcc-dev/neofs-node/pkg/services/object/internal/client"
 	"github.com/nspcc-dev/neofs-node/pkg/services/object/util"
 	"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/transformer"
@@ -36,7 +37,7 @@ type RemoteSender struct {
 
 // RemotePutPrm groups remote put operation parameters.
 type RemotePutPrm struct {
-	node *netmap.NodeInfo
+	node netmap.NodeInfo
 
 	obj *object.Object
 }
@@ -95,7 +96,7 @@ func NewRemoteSender(keyStorage *util.KeyStorage, cons ClientConstructor) *Remot
 }
 
 // WithNodeInfo sets information about the remote node.
-func (p *RemotePutPrm) WithNodeInfo(v *netmap.NodeInfo) *RemotePutPrm {
+func (p *RemotePutPrm) WithNodeInfo(v netmap.NodeInfo) *RemotePutPrm {
 	if p != nil {
 		p.node = v
 	}
@@ -120,7 +121,7 @@ func (s *RemoteSender) PutObject(ctx context.Context, p *RemotePutPrm) error {
 		clientConstructor: s.clientConstructor,
 	}
 
-	err := clientcore.NodeInfoFromRawNetmapElement(&t.nodeInfo, p.node)
+	err := clientcore.NodeInfoFromRawNetmapElement(&t.nodeInfo, netmapCore.Node(p.node))
 	if err != nil {
 		return fmt.Errorf("parse client node info: %w", err)
 	}
diff --git a/pkg/services/object/search/search_test.go b/pkg/services/object/search/search_test.go
index 808478508..7ce3a4c52 100644
--- a/pkg/services/object/search/search_test.go
+++ b/pkg/services/object/search/search_test.go
@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	clientcore "github.com/nspcc-dev/neofs-node/pkg/core/client"
+	netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/network"
 	"github.com/nspcc-dev/neofs-node/pkg/services/object/util"
 	"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/placement"
@@ -37,7 +38,7 @@ type testTraverserGenerator struct {
 }
 
 type testPlacementBuilder struct {
-	vectors map[string][]netmap.Nodes
+	vectors map[string][][]netmap.NodeInfo
 }
 
 type testClientCache struct {
@@ -73,7 +74,7 @@ func (g *testTraverserGenerator) generateTraverser(_ cid.ID, epoch uint64) (*pla
 	)
 }
 
-func (p *testPlacementBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, _ *netmap.PlacementPolicy) ([]netmap.Nodes, error) {
+func (p *testPlacementBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, _ netmap.PlacementPolicy) ([][]netmap.NodeInfo, error) {
 	var addr oid.Address
 	addr.SetContainer(cnr)
 
@@ -86,7 +87,7 @@ func (p *testPlacementBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, _ *netmap
 		return nil, errors.New("vectors for address not found")
 	}
 
-	res := make([]netmap.Nodes, len(vs))
+	res := make([][]netmap.NodeInfo, len(vs))
 	copy(res, vs)
 
 	return res, nil
@@ -193,8 +194,8 @@ func TestGetLocalOnly(t *testing.T) {
 	})
 }
 
-func testNodeMatrix(t testing.TB, dim []int) ([]netmap.Nodes, [][]string) {
-	mNodes := make([]netmap.Nodes, len(dim))
+func testNodeMatrix(t testing.TB, dim []int) ([][]netmap.NodeInfo, [][]string) {
+	mNodes := make([][]netmap.NodeInfo, len(dim))
 	mAddr := make([][]string, len(dim))
 
 	for i := range dim {
@@ -207,20 +208,20 @@ func testNodeMatrix(t testing.TB, dim []int) ([]netmap.Nodes, [][]string) {
 				strconv.Itoa(60000+j),
 			)
 
-			ni := netmap.NewNodeInfo()
-			ni.SetAddresses(a)
+			var ni netmap.NodeInfo
+			ni.SetNetworkEndpoints(a)
 
 			var na network.AddressGroup
 
-			err := na.FromIterator(ni)
+			err := na.FromIterator(netmapcore.Node(ni))
 			require.NoError(t, err)
 
 			as[j] = network.StringifyGroup(na)
 
-			ns[j] = *ni
+			ns[j] = ni
 		}
 
-		mNodes[i] = netmap.NodesFromInfo(ns)
+		mNodes[i] = ns
 		mAddr[i] = as
 	}
 
@@ -232,15 +233,15 @@ func TestGetRemoteSmall(t *testing.T) {
 
 	placementDim := []int{2}
 
-	rs := make([]netmap.Replica, len(placementDim))
+	rs := make([]netmap.ReplicaDescriptor, len(placementDim))
 	for i := range placementDim {
-		rs[i].SetCount(uint32(placementDim[i]))
+		rs[i].SetNumberOfObjects(uint32(placementDim[i]))
 	}
 
-	pp := netmap.NewPlacementPolicy()
-	pp.SetReplicas(rs...)
+	var pp netmap.PlacementPolicy
+	pp.AddReplicas(rs...)
 
-	cnr := container.New(container.WithPolicy(pp))
+	cnr := container.New(container.WithPolicy(&pp))
 	id := container.CalculateID(cnr)
 
 	newSvc := func(b *testPlacementBuilder, c *testClientCache) *Service {
@@ -278,7 +279,7 @@ func TestGetRemoteSmall(t *testing.T) {
 		ns, as := testNodeMatrix(t, placementDim)
 
 		builder := &testPlacementBuilder{
-			vectors: map[string][]netmap.Nodes{
+			vectors: map[string][][]netmap.NodeInfo{
 				addr.EncodeToString(): ns,
 			},
 		}
@@ -317,16 +318,16 @@ func TestGetFromPastEpoch(t *testing.T) {
 
 	placementDim := []int{2, 2}
 
-	rs := make([]netmap.Replica, len(placementDim))
+	rs := make([]netmap.ReplicaDescriptor, len(placementDim))
 
 	for i := range placementDim {
-		rs[i].SetCount(uint32(placementDim[i]))
+		rs[i].SetNumberOfObjects(uint32(placementDim[i]))
 	}
 
-	pp := netmap.NewPlacementPolicy()
-	pp.SetReplicas(rs...)
+	var pp netmap.PlacementPolicy
+	pp.AddReplicas(rs...)
 
-	cnr := container.New(container.WithPolicy(pp))
+	cnr := container.New(container.WithPolicy(&pp))
 	idCnr := container.CalculateID(cnr)
 
 	var addr oid.Address
@@ -360,12 +361,12 @@ func TestGetFromPastEpoch(t *testing.T) {
 		c: cnr,
 		b: map[uint64]placement.Builder{
 			curEpoch: &testPlacementBuilder{
-				vectors: map[string][]netmap.Nodes{
+				vectors: map[string][][]netmap.NodeInfo{
 					addr.EncodeToString(): ns[:1],
 				},
 			},
 			curEpoch - 1: &testPlacementBuilder{
-				vectors: map[string][]netmap.Nodes{
+				vectors: map[string][][]netmap.NodeInfo{
 					addr.EncodeToString(): ns[1:],
 				},
 			},
diff --git a/pkg/services/object/util/placement.go b/pkg/services/object/util/placement.go
index 3e52c398e..742f007e9 100644
--- a/pkg/services/object/util/placement.go
+++ b/pkg/services/object/util/placement.go
@@ -43,7 +43,7 @@ func NewLocalPlacement(b placement.Builder, s netmap.AnnouncedKeys) placement.Bu
 	}
 }
 
-func (p *localPlacement) BuildPlacement(cnr cid.ID, obj *oid.ID, policy *netmapSDK.PlacementPolicy) ([]netmapSDK.Nodes, error) {
+func (p *localPlacement) BuildPlacement(cnr cid.ID, obj *oid.ID, policy netmapSDK.PlacementPolicy) ([][]netmapSDK.NodeInfo, error) {
 	vs, err := p.builder.BuildPlacement(cnr, obj, policy)
 	if err != nil {
 		return nil, fmt.Errorf("(%T) could not build object placement: %w", p, err)
@@ -53,13 +53,13 @@ func (p *localPlacement) BuildPlacement(cnr cid.ID, obj *oid.ID, policy *netmapS
 		for j := range vs[i] {
 			var addr network.AddressGroup
 
-			err := addr.FromIterator(vs[i][j])
+			err := addr.FromIterator(network.NodeEndpointsIterator(vs[i][j]))
 			if err != nil {
 				continue
 			}
 
 			if p.netmapKeys.IsLocalKey(vs[i][j].PublicKey()) {
-				return []netmapSDK.Nodes{{vs[i][j]}}, nil
+				return [][]netmapSDK.NodeInfo{{vs[i][j]}}, nil
 			}
 		}
 	}
@@ -76,7 +76,7 @@ func NewRemotePlacementBuilder(b placement.Builder, s netmap.AnnouncedKeys) plac
 	}
 }
 
-func (p *remotePlacement) BuildPlacement(cnr cid.ID, obj *oid.ID, policy *netmapSDK.PlacementPolicy) ([]netmapSDK.Nodes, error) {
+func (p *remotePlacement) BuildPlacement(cnr cid.ID, obj *oid.ID, policy netmapSDK.PlacementPolicy) ([][]netmapSDK.NodeInfo, error) {
 	vs, err := p.builder.BuildPlacement(cnr, obj, policy)
 	if err != nil {
 		return nil, fmt.Errorf("(%T) could not build object placement: %w", p, err)
@@ -86,7 +86,7 @@ func (p *remotePlacement) BuildPlacement(cnr cid.ID, obj *oid.ID, policy *netmap
 		for j := 0; j < len(vs[i]); j++ {
 			var addr network.AddressGroup
 
-			err := addr.FromIterator(vs[i][j])
+			err := addr.FromIterator(network.NodeEndpointsIterator(vs[i][j]))
 			if err != nil {
 				continue
 			}
diff --git a/pkg/services/object_manager/placement/netmap.go b/pkg/services/object_manager/placement/netmap.go
index 0c67b7470..2d581adb3 100644
--- a/pkg/services/object_manager/placement/netmap.go
+++ b/pkg/services/object_manager/placement/netmap.go
@@ -16,7 +16,7 @@ type netMapBuilder struct {
 	nmSrc netmap.Source
 	// mtx protects lastNm and containerCache fields.
 	mtx    sync.Mutex
-	lastNm *netmapSDK.Netmap
+	lastNm *netmapSDK.NetMap
 	// containerCache caches container nodes by ID. It is used to skip `GetContainerNodes` invocation if
 	// neither netmap nor container has changed.
 	containerCache simplelru.LRUCache
@@ -25,13 +25,13 @@ type netMapBuilder struct {
 type netMapSrc struct {
 	netmap.Source
 
-	nm *netmapSDK.Netmap
+	nm *netmapSDK.NetMap
 }
 
 // defaultContainerCacheSize is the default size for the container cache.
 const defaultContainerCacheSize = 10
 
-func NewNetworkMapBuilder(nm *netmapSDK.Netmap) Builder {
+func NewNetworkMapBuilder(nm *netmapSDK.NetMap) Builder {
 	cache, _ := simplelru.NewLRU(defaultContainerCacheSize, nil) // no error
 	return &netMapBuilder{
 		nmSrc:          &netMapSrc{nm: nm},
@@ -47,11 +47,11 @@ func NewNetworkMapSourceBuilder(nmSrc netmap.Source) Builder {
 	}
 }
 
-func (s *netMapSrc) GetNetMap(diff uint64) (*netmapSDK.Netmap, error) {
+func (s *netMapSrc) GetNetMap(diff uint64) (*netmapSDK.NetMap, error) {
 	return s.nm, nil
 }
 
-func (b *netMapBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, p *netmapSDK.PlacementPolicy) ([]netmapSDK.Nodes, error) {
+func (b *netMapBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, p netmapSDK.PlacementPolicy) ([][]netmapSDK.NodeInfo, error) {
 	nm, err := netmap.GetLatestNetworkMap(b.nmSrc)
 	if err != nil {
 		return nil, fmt.Errorf("could not get network map: %w", err)
@@ -65,7 +65,7 @@ func (b *netMapBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, p *netmapSDK.Pla
 		raw, ok := b.containerCache.Get(string(binCnr))
 		b.mtx.Unlock()
 		if ok {
-			cn := raw.(netmapSDK.ContainerNodes)
+			cn := raw.([][]netmapSDK.NodeInfo)
 			return BuildObjectPlacement(nm, cn, obj)
 		}
 	} else {
@@ -73,7 +73,7 @@ func (b *netMapBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, p *netmapSDK.Pla
 		b.mtx.Unlock()
 	}
 
-	cn, err := nm.GetContainerNodes(p, binCnr)
+	cn, err := nm.ContainerNodes(p, binCnr)
 	if err != nil {
 		return nil, fmt.Errorf("could not get container nodes: %w", err)
 	}
@@ -85,15 +85,15 @@ func (b *netMapBuilder) BuildPlacement(cnr cid.ID, obj *oid.ID, p *netmapSDK.Pla
 	return BuildObjectPlacement(nm, cn, obj)
 }
 
-func BuildObjectPlacement(nm *netmapSDK.Netmap, cnrNodes netmapSDK.ContainerNodes, id *oid.ID) ([]netmapSDK.Nodes, error) {
+func BuildObjectPlacement(nm *netmapSDK.NetMap, cnrNodes [][]netmapSDK.NodeInfo, id *oid.ID) ([][]netmapSDK.NodeInfo, error) {
 	if id == nil {
-		return cnrNodes.Replicas(), nil
+		return cnrNodes, nil
 	}
 
 	binObj := make([]byte, sha256.Size)
 	id.Encode(binObj)
 
-	on, err := nm.GetPlacementVectors(cnrNodes, binObj)
+	on, err := nm.PlacementVectors(cnrNodes, binObj)
 	if err != nil {
 		return nil, fmt.Errorf("could not get placement vectors for object: %w", err)
 	}
@@ -102,8 +102,15 @@ func BuildObjectPlacement(nm *netmapSDK.Netmap, cnrNodes netmapSDK.ContainerNode
 }
 
 // FlattenNodes appends each row to the flat list.
-func FlattenNodes(ns []netmapSDK.Nodes) netmapSDK.Nodes {
-	result := make(netmapSDK.Nodes, 0, len(ns))
+func FlattenNodes(ns [][]netmapSDK.NodeInfo) []netmapSDK.NodeInfo {
+	var sz int
+
+	for i := range ns {
+		sz += len(ns[i])
+	}
+
+	result := make([]netmapSDK.NodeInfo, 0, sz)
+
 	for i := range ns {
 		result = append(result, ns[i]...)
 	}
diff --git a/pkg/services/object_manager/placement/traverser.go b/pkg/services/object_manager/placement/traverser.go
index 3f78bcfa0..7ccf40470 100644
--- a/pkg/services/object_manager/placement/traverser.go
+++ b/pkg/services/object_manager/placement/traverser.go
@@ -20,7 +20,7 @@ type Builder interface {
 	//
 	// Must return all container nodes if object identifier
 	// is nil.
-	BuildPlacement(cid.ID, *oid.ID, *netmap.PlacementPolicy) ([]netmap.Nodes, error)
+	BuildPlacement(cid.ID, *oid.ID, netmap.PlacementPolicy) ([][]netmap.NodeInfo, error)
 }
 
 // Option represents placement traverser option.
@@ -31,7 +31,7 @@ type Option func(*cfg)
 type Traverser struct {
 	mtx *sync.RWMutex
 
-	vectors []netmap.Nodes
+	vectors [][]netmap.NodeInfo
 
 	rem []int
 }
@@ -78,7 +78,7 @@ func NewTraverser(opts ...Option) (*Traverser, error) {
 		return nil, fmt.Errorf("%s: %w", invalidOptsMsg, errNilPolicy)
 	}
 
-	ns, err := cfg.builder.BuildPlacement(cfg.cnr, cfg.obj, cfg.policy)
+	ns, err := cfg.builder.BuildPlacement(cfg.cnr, cfg.obj, *cfg.policy)
 	if err != nil {
 		return nil, fmt.Errorf("could not build placement: %w", err)
 	}
@@ -88,12 +88,12 @@ func NewTraverser(opts ...Option) (*Traverser, error) {
 		ns = flatNodes(ns)
 		rem = []int{int(*cfg.flatSuccess)}
 	} else {
-		rs := cfg.policy.Replicas()
-		rem = make([]int, 0, len(rs))
+		replNum := cfg.policy.NumberOfReplicas()
+		rem = make([]int, 0, replNum)
 
-		for i := range rs {
+		for i := 0; i < replNum; i++ {
 			if cfg.trackCopies {
-				rem = append(rem, int(rs[i].Count()))
+				rem = append(rem, int(cfg.policy.ReplicaNumberByIndex(i)))
 			} else {
 				rem = append(rem, -1)
 			}
@@ -107,18 +107,18 @@ func NewTraverser(opts ...Option) (*Traverser, error) {
 	}, nil
 }
 
-func flatNodes(ns []netmap.Nodes) []netmap.Nodes {
+func flatNodes(ns [][]netmap.NodeInfo) [][]netmap.NodeInfo {
 	sz := 0
 	for i := range ns {
 		sz += len(ns[i])
 	}
 
-	flat := make(netmap.Nodes, 0, sz)
+	flat := make([]netmap.NodeInfo, 0, sz)
 	for i := range ns {
 		flat = append(flat, ns[i]...)
 	}
 
-	return []netmap.Nodes{flat}
+	return [][]netmap.NodeInfo{flat}
 }
 
 // Node is a descriptor of storage node with information required for intra-container communication.
@@ -161,7 +161,7 @@ func (t *Traverser) Next() []Node {
 	nodes := make([]Node, count)
 
 	for i := 0; i < count; i++ {
-		err := nodes[i].addresses.FromIterator(t.vectors[0][i])
+		err := nodes[i].addresses.FromIterator(network.NodeEndpointsIterator(t.vectors[0][i]))
 		if err != nil {
 			return nil
 		}
diff --git a/pkg/services/object_manager/placement/traverser_test.go b/pkg/services/object_manager/placement/traverser_test.go
index d2e159f89..0dc46c05e 100644
--- a/pkg/services/object_manager/placement/traverser_test.go
+++ b/pkg/services/object_manager/placement/traverser_test.go
@@ -4,6 +4,7 @@ import (
 	"strconv"
 	"testing"
 
+	netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
 	"github.com/nspcc-dev/neofs-node/pkg/network"
 	"github.com/nspcc-dev/neofs-sdk-go/container"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
@@ -13,24 +14,24 @@ import (
 )
 
 type testBuilder struct {
-	vectors []netmap.Nodes
+	vectors [][]netmap.NodeInfo
 }
 
-func (b testBuilder) BuildPlacement(cid.ID, *oid.ID, *netmap.PlacementPolicy) ([]netmap.Nodes, error) {
+func (b testBuilder) BuildPlacement(cid.ID, *oid.ID, netmap.PlacementPolicy) ([][]netmap.NodeInfo, error) {
 	return b.vectors, nil
 }
 
 func testNode(v uint32) (n netmap.NodeInfo) {
-	n.SetAddresses("/ip4/0.0.0.0/tcp/" + strconv.Itoa(int(v)))
+	n.SetNetworkEndpoints("/ip4/0.0.0.0/tcp/" + strconv.Itoa(int(v)))
 
 	return n
 }
 
-func copyVectors(v []netmap.Nodes) []netmap.Nodes {
-	vc := make([]netmap.Nodes, 0, len(v))
+func copyVectors(v [][]netmap.NodeInfo) [][]netmap.NodeInfo {
+	vc := make([][]netmap.NodeInfo, 0, len(v))
 
 	for i := range v {
-		ns := make(netmap.Nodes, len(v[i]))
+		ns := make([]netmap.NodeInfo, len(v[i]))
 		copy(ns, v[i])
 
 		vc = append(vc, ns)
@@ -39,9 +40,9 @@ func copyVectors(v []netmap.Nodes) []netmap.Nodes {
 	return vc
 }
 
-func testPlacement(t *testing.T, ss, rs []int) ([]netmap.Nodes, *container.Container) {
-	nodes := make([]netmap.Nodes, 0, len(rs))
-	replicas := make([]netmap.Replica, 0, len(rs))
+func testPlacement(t *testing.T, ss, rs []int) ([][]netmap.NodeInfo, *container.Container) {
+	nodes := make([][]netmap.NodeInfo, 0, len(rs))
+	replicas := make([]netmap.ReplicaDescriptor, 0, len(rs))
 	num := uint32(0)
 
 	for i := range ss {
@@ -52,24 +53,24 @@ func testPlacement(t *testing.T, ss, rs []int) ([]netmap.Nodes, *container.Conta
 			num++
 		}
 
-		nodes = append(nodes, netmap.NodesFromInfo(ns))
+		nodes = append(nodes, ns)
 
-		var s netmap.Replica
-		s.SetCount(uint32(rs[i]))
+		var rd netmap.ReplicaDescriptor
+		rd.SetNumberOfObjects(uint32(rs[i]))
 
-		replicas = append(replicas, s)
+		replicas = append(replicas, rd)
 	}
 
 	policy := new(netmap.PlacementPolicy)
-	policy.SetReplicas(replicas...)
+	policy.AddReplicas(replicas...)
 
 	return nodes, container.New(container.WithPolicy(policy))
 }
 
-func assertSameAddress(t *testing.T, ni *netmap.NodeInfo, addr network.AddressGroup) {
+func assertSameAddress(t *testing.T, ni netmap.NodeInfo, addr network.AddressGroup) {
 	var netAddr network.AddressGroup
 
-	err := netAddr.FromIterator(ni)
+	err := netAddr.FromIterator(netmapcore.Node(ni))
 	require.NoError(t, err)
 	require.True(t, netAddr.Intersects(addr))
 }
@@ -96,7 +97,7 @@ func TestTraverserObjectScenarios(t *testing.T) {
 			require.Len(t, addrs, len(nodes[i]))
 
 			for j, n := range nodes[i] {
-				assertSameAddress(t, n.NodeInfo, addrs[j].Addresses())
+				assertSameAddress(t, n, addrs[j].Addresses())
 			}
 		}
 
@@ -127,7 +128,7 @@ func TestTraverserObjectScenarios(t *testing.T) {
 
 		var n network.AddressGroup
 
-		err = n.FromIterator(nodes[1][0])
+		err = n.FromIterator(netmapcore.Node(nodes[1][0]))
 		require.NoError(t, err)
 
 		require.Equal(t, []Node{{addresses: n}}, tr.Next())
@@ -153,7 +154,7 @@ func TestTraverserObjectScenarios(t *testing.T) {
 				require.Len(t, addrs, replicas[curVector])
 
 				for j := range addrs {
-					assertSameAddress(t, nodes[curVector][i+j].NodeInfo, addrs[j].Addresses())
+					assertSameAddress(t, nodes[curVector][i+j], addrs[j].Addresses())
 				}
 			}
 
@@ -185,7 +186,7 @@ func TestTraverserObjectScenarios(t *testing.T) {
 		tr, err := NewTraverser(
 			ForContainer(cnr),
 			UseBuilder(&testBuilder{
-				vectors: []netmap.Nodes{{nodes[1][1]}}, // single node (local)
+				vectors: [][]netmap.NodeInfo{{nodes[1][1]}}, // single node (local)
 			}),
 			SuccessAfter(1),
 		)
diff --git a/pkg/services/policer/check.go b/pkg/services/policer/check.go
index cb8e179f9..95a3df2de 100644
--- a/pkg/services/policer/check.go
+++ b/pkg/services/policer/check.go
@@ -45,9 +45,17 @@ func (p *Policer) processObject(ctx context.Context, addr oid.Address) {
 	}
 
 	policy := cnr.PlacementPolicy()
+	if policy == nil {
+		p.log.Error("missing placement policy in container",
+			zap.Stringer("cid", idCnr),
+		)
+
+		return
+	}
+
 	obj := addr.Object()
 
-	nn, err := p.placementBuilder.BuildPlacement(idCnr, &obj, policy)
+	nn, err := p.placementBuilder.BuildPlacement(idCnr, &obj, *policy)
 	if err != nil {
 		p.log.Error("could not build placement vector for object",
 			zap.String("error", err.Error()),
@@ -56,7 +64,6 @@ func (p *Policer) processObject(ctx context.Context, addr oid.Address) {
 		return
 	}
 
-	replicas := policy.Replicas()
 	c := &processPlacementContext{
 		Context: ctx,
 	}
@@ -76,7 +83,7 @@ func (p *Policer) processObject(ctx context.Context, addr oid.Address) {
 		default:
 		}
 
-		p.processNodes(c, addr, nn[i], replicas[i].Count(), checkedNodes)
+		p.processNodes(c, addr, nn[i], policy.ReplicaNumberByIndex(i), checkedNodes)
 	}
 
 	if !c.needLocalCopy {
@@ -95,7 +102,7 @@ type processPlacementContext struct {
 }
 
 func (p *Policer) processNodes(ctx *processPlacementContext, addr oid.Address,
-	nodes netmap.Nodes, shortage uint32, checkedNodes nodeCache) {
+	nodes []netmap.NodeInfo, shortage uint32, checkedNodes nodeCache) {
 	prm := new(headsvc.RemoteHeadPrm).WithObjectAddress(addr)
 
 	for i := 0; shortage > 0 && i < len(nodes); i++ {
@@ -110,7 +117,8 @@ func (p *Policer) processNodes(ctx *processPlacementContext, addr oid.Address,
 
 			shortage--
 		} else {
-			if hasReplica, checked := checkedNodes[nodes[i].ID]; checked {
+			nodeID := nodes[i].Hash()
+			if hasReplica, checked := checkedNodes[nodeID]; checked {
 				if hasReplica {
 					// node already contains replica, no need to replicate
 					nodes = append(nodes[:i], nodes[i+1:]...)
@@ -123,7 +131,7 @@ func (p *Policer) processNodes(ctx *processPlacementContext, addr oid.Address,
 
 			callCtx, cancel := context.WithTimeout(ctx, p.headTimeout)
 
-			_, err := p.remoteHeader.Head(callCtx, prm.WithNodeInfo(nodes[i].NodeInfo))
+			_, err := p.remoteHeader.Head(callCtx, prm.WithNodeInfo(nodes[i]))
 
 			cancel()
 
@@ -133,7 +141,7 @@ func (p *Policer) processNodes(ctx *processPlacementContext, addr oid.Address,
 			}
 
 			if client.IsErrObjectNotFound(err) {
-				checkedNodes[nodes[i].ID] = false
+				checkedNodes[nodeID] = false
 				continue
 			}
 
@@ -144,7 +152,7 @@ func (p *Policer) processNodes(ctx *processPlacementContext, addr oid.Address,
 				)
 			} else {
 				shortage--
-				checkedNodes[nodes[i].ID] = true
+				checkedNodes[nodeID] = true
 			}
 		}
 
diff --git a/pkg/services/replicator/process.go b/pkg/services/replicator/process.go
index 033f4fdc5..91d8fd3d0 100644
--- a/pkg/services/replicator/process.go
+++ b/pkg/services/replicator/process.go
@@ -52,7 +52,7 @@ func (p *Replicator) HandleTask(ctx context.Context, task *Task, res TaskResult)
 
 		callCtx, cancel := context.WithTimeout(ctx, p.putTimeout)
 
-		err = p.remoteSender.PutObject(callCtx, prm.WithNodeInfo(task.nodes[i].NodeInfo))
+		err = p.remoteSender.PutObject(callCtx, prm.WithNodeInfo(task.nodes[i]))
 
 		cancel()
 
@@ -65,7 +65,7 @@ func (p *Replicator) HandleTask(ctx context.Context, task *Task, res TaskResult)
 
 			task.quantity--
 
-			res.SubmitSuccessfulReplication(task.nodes[i].ID)
+			res.SubmitSuccessfulReplication(task.nodes[i].Hash())
 		}
 	}
 }
diff --git a/pkg/services/replicator/task.go b/pkg/services/replicator/task.go
index d40cde6b1..99d1c5139 100644
--- a/pkg/services/replicator/task.go
+++ b/pkg/services/replicator/task.go
@@ -11,7 +11,7 @@ type Task struct {
 
 	addr oid.Address
 
-	nodes netmap.Nodes
+	nodes []netmap.NodeInfo
 }
 
 // WithCopiesNumber sets number of copies to replicate.
@@ -33,7 +33,7 @@ func (t *Task) WithObjectAddress(v oid.Address) *Task {
 }
 
 // WithNodes sets a list of potential object holders.
-func (t *Task) WithNodes(v netmap.Nodes) *Task {
+func (t *Task) WithNodes(v []netmap.NodeInfo) *Task {
 	if t != nil {
 		t.nodes = v
 	}
diff --git a/pkg/services/reputation/common/managers.go b/pkg/services/reputation/common/managers.go
index 64f5f094d..7f45f8c7e 100644
--- a/pkg/services/reputation/common/managers.go
+++ b/pkg/services/reputation/common/managers.go
@@ -56,6 +56,21 @@ func NewManagerBuilder(prm ManagersPrm, opts ...MngOption) ManagerBuilder {
 	}
 }
 
+// implements Server on apiNetmap.NodeInfo
+type nodeServer apiNetmap.NodeInfo
+
+func (x nodeServer) PublicKey() []byte {
+	return (apiNetmap.NodeInfo)(x).PublicKey()
+}
+
+func (x nodeServer) IterateAddresses(f func(string) bool) {
+	(apiNetmap.NodeInfo)(x).IterateNetworkEndpoints(f)
+}
+
+func (x nodeServer) NumberOfAddresses() int {
+	return (apiNetmap.NodeInfo)(x).NumberOfNetworkEndpoints()
+}
+
 // BuildManagers sorts nodes in NetMap with HRW algorithms and
 // takes the next node after the current one as the only manager.
 func (mb *managerBuilder) BuildManagers(epoch uint64, p reputation.PeerID) ([]ServerInfo, error) {
@@ -69,10 +84,12 @@ func (mb *managerBuilder) BuildManagers(epoch uint64, p reputation.PeerID) ([]Se
 		return nil, err
 	}
 
-	// make a copy to keep order consistency of the origin netmap after sorting
-	nodes := make([]apiNetmap.Node, len(nm.Nodes))
+	nmNodes := nm.Nodes()
 
-	copy(nodes, nm.Nodes)
+	// make a copy to keep order consistency of the origin netmap after sorting
+	nodes := make([]apiNetmap.NodeInfo, len(nmNodes))
+
+	copy(nodes, nmNodes)
 
 	hrw.SortSliceByValue(nodes, epoch)
 
@@ -84,7 +101,7 @@ func (mb *managerBuilder) BuildManagers(epoch uint64, p reputation.PeerID) ([]Se
 				managerIndex = 0
 			}
 
-			return []ServerInfo{nodes[managerIndex]}, nil
+			return []ServerInfo{nodeServer(nodes[managerIndex])}, nil
 		}
 	}
 
diff --git a/pkg/util/attributes/parser.go b/pkg/util/attributes/parser.go
index 2af03486c..efb5c7985 100644
--- a/pkg/util/attributes/parser.go
+++ b/pkg/util/attributes/parser.go
@@ -8,104 +8,63 @@ import (
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 )
 
-const (
-	pairSeparator     = "/"
-	keyValueSeparator = ":"
-)
+const keyValueSeparator = ":"
 
-var (
-	errEmptyChain      = errors.New("empty attribute chain")
-	errNonUniqueBucket = errors.New("attributes must contain unique keys")
-	errUnexpectedKey   = errors.New("attributes contain unexpected key")
-)
-
-// ParseV2Attributes parses strings like "K1:V1/K2:V2/K3:V3" into netmap
-// attributes. Supports escaped symbols "\:", "\/" and "\\".
-func ParseV2Attributes(attrs []string, excl []string) ([]netmap.NodeAttribute, error) {
-	restricted := make(map[string]struct{}, len(excl))
-	for i := range excl {
-		restricted[excl[i]] = struct{}{}
-	}
-
-	cache := make(map[string]*netmap.NodeAttribute, len(attrs))
-	result := make([]netmap.NodeAttribute, 0, len(attrs))
+// ReadNodeAttributes parses node attributes from list of string in "Key:Value" format
+// and writes them into netmap.NodeInfo instance. Supports escaped symbols
+// "\:", "\/" and "\\".
+func ReadNodeAttributes(dst *netmap.NodeInfo, attrs []string) error {
+	cache := make(map[string]struct{}, len(attrs))
 
 	for i := range attrs {
-		line := strings.Trim(attrs[i], pairSeparator)
-		line = replaceEscaping(line, false) // replaced escaped symbols with non-printable symbols
-		chain := strings.Split(line, pairSeparator)
-		if len(chain) == 0 {
-			return nil, errEmptyChain
+		line := replaceEscaping(attrs[i], false) // replaced escaped symbols with non-printable symbols
+
+		words := strings.Split(line, keyValueSeparator)
+		if len(words) != 2 {
+			return errors.New("missing attribute key and/or value")
 		}
 
-		var parentKey string // backtrack parents in next pairs
-
-		for j := range chain {
-			pair := strings.Split(chain[j], keyValueSeparator)
-			if len(pair) != 2 {
-				return nil, fmt.Errorf("incorrect attribute pair %s", chain[j])
-			}
-
-			key := pair[0]
-			value := pair[1]
-
-			attribute, present := cache[key]
-			if present && attribute.Value() != value {
-				return nil, errNonUniqueBucket
-			}
-
-			if _, ok := restricted[key]; ok {
-				return nil, errUnexpectedKey
-			}
-
-			if !present {
-				result = append(result, netmap.NodeAttribute{})
-				attribute = &result[len(result)-1]
-				cache[key] = attribute
-
-				// replace non-printable symbols with escaped symbols without escape character
-				key = replaceEscaping(key, true)
-				value = replaceEscaping(value, true)
-
-				attribute.SetKey(key)
-				attribute.SetValue(value)
-			}
-
-			if parentKey != "" {
-				parentKeys := attribute.ParentKeys()
-				if !hasString(parentKeys, parentKey) {
-					attribute.SetParentKeys(append(parentKeys, parentKey)...)
-				}
-			}
-
-			parentKey = key
+		_, ok := cache[words[0]]
+		if ok {
+			return fmt.Errorf("duplicated keys %s", words[0])
 		}
+
+		cache[words[0]] = struct{}{}
+
+		// replace non-printable symbols with escaped symbols without escape character
+		words[0] = replaceEscaping(words[0], true)
+		words[1] = replaceEscaping(words[1], true)
+		fmt.Println(words[0], words[1])
+
+		if words[0] == "" {
+			return errors.New("empty key")
+		} else if words[1] == "" {
+			return errors.New("empty value")
+		}
+
+		dst.SetAttribute(words[0], words[1])
 	}
 
-	return result, nil
+	return nil
 }
 
 func replaceEscaping(target string, rollback bool) (s string) {
 	const escChar = `\`
 
 	var (
-		oldPairSep = escChar + pairSeparator
-		oldKVSep   = escChar + keyValueSeparator
-		oldEsc     = escChar + escChar
-		newPairSep = string(uint8(1))
-		newKVSep   = string(uint8(2))
-		newEsc     = string(uint8(3))
+		oldKVSep = escChar + keyValueSeparator
+		oldEsc   = escChar + escChar
+		newKVSep = string(uint8(2))
+		newEsc   = string(uint8(3))
 	)
 
 	if rollback {
-		oldPairSep, oldKVSep, oldEsc = newPairSep, newKVSep, newEsc
-		newPairSep = pairSeparator
+		oldKVSep, oldEsc = newKVSep, newEsc
 		newKVSep = keyValueSeparator
 		newEsc = escChar
 	}
 
 	s = strings.ReplaceAll(target, oldEsc, newEsc)
-	s = strings.ReplaceAll(s, oldPairSep, newPairSep)
 	s = strings.ReplaceAll(s, oldKVSep, newKVSep)
 
 	return
diff --git a/pkg/util/attributes/parser_test.go b/pkg/util/attributes/parser_test.go
index 87fcef2a0..03db0bdcf 100644
--- a/pkg/util/attributes/parser_test.go
+++ b/pkg/util/attributes/parser_test.go
@@ -4,117 +4,96 @@ import (
 	"testing"
 
 	"github.com/nspcc-dev/neofs-node/pkg/util/attributes"
+	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 	"github.com/stretchr/testify/require"
 )
 
-func TestParseV2Attributes(t *testing.T) {
-	t.Run("empty", func(t *testing.T) {
-		attrs, err := attributes.ParseV2Attributes(nil, nil)
-		require.NoError(t, err)
-		require.Len(t, attrs, 0)
+func testAttributeMap(t *testing.T, mSrc, mExp map[string]string) {
+	var node netmap.NodeInfo
+
+	s := make([]string, 0, len(mSrc))
+	for k, v := range mSrc {
+		s = append(s, k+":"+v)
+	}
+
+	err := attributes.ReadNodeAttributes(&node, s)
+	require.NoError(t, err)
+
+	if mExp == nil {
+		mExp = mSrc
+	}
+
+	node.IterateAttributes(func(key, value string) {
+		v, ok := mExp[key]
+		require.True(t, ok)
+		require.Equal(t, value, v)
+		delete(mExp, key)
 	})
 
-	t.Run("non unique bucket keys", func(t *testing.T) {
-		good := []string{
-			"StorageType:HDD/RPM:7200",
-			"StorageType:HDD/SMR:True",
-		}
-		_, err := attributes.ParseV2Attributes(good, nil)
-		require.NoError(t, err)
+	require.Empty(t, mExp)
+}
 
-		bad := append(good, "StorageType:SSD/Cell:QLC")
-		_, err = attributes.ParseV2Attributes(bad, nil)
+func TestParseV2Attributes(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		var node netmap.NodeInfo
+		err := attributes.ReadNodeAttributes(&node, nil)
+		require.NoError(t, err)
+		require.Zero(t, node.NumberOfAttributes())
+	})
+
+	t.Run("empty key and/or value", func(t *testing.T) {
+		var node netmap.NodeInfo
+		err := attributes.ReadNodeAttributes(&node, []string{
+			":HDD",
+		})
+		require.Error(t, err)
+
+		err = attributes.ReadNodeAttributes(&node, []string{
+			"StorageType:",
+		})
+		require.Error(t, err)
+
+		err = attributes.ReadNodeAttributes(&node, []string{
+			":",
+		})
+		require.Error(t, err)
+	})
+
+	t.Run("non-unique keys", func(t *testing.T) {
+		var node netmap.NodeInfo
+		err := attributes.ReadNodeAttributes(&node, []string{
+			"StorageType:HDD",
+			"StorageType:HDD",
+		})
 		require.Error(t, err)
 	})
 
 	t.Run("malformed", func(t *testing.T) {
-		_, err := attributes.ParseV2Attributes([]string{"..."}, nil)
+		var node netmap.NodeInfo
+		err := attributes.ReadNodeAttributes(&node, []string{"..."})
 		require.Error(t, err)
 
-		_, err = attributes.ParseV2Attributes([]string{"a:b", ""}, nil)
+		err = attributes.ReadNodeAttributes(&node, []string{"a:b", ""})
 		require.Error(t, err)
 
-		_, err = attributes.ParseV2Attributes([]string{"//"}, nil)
-		require.Error(t, err)
-	})
-
-	t.Run("unexpected", func(t *testing.T) {
-		unexpectedBucket := []string{
-			"Location:Europe/City:Moscow",
-			"Price:100",
-		}
-		_, err := attributes.ParseV2Attributes(unexpectedBucket, []string{"Price"})
+		err = attributes.ReadNodeAttributes(&node, []string{"//"})
 		require.Error(t, err)
 	})
 
 	t.Run("correct", func(t *testing.T) {
-		from := []string{
-			"/Location:Europe/Country:Sweden/City:Stockholm",
-			"/StorageType:HDD/RPM:7200",
-		}
-		attrs, err := attributes.ParseV2Attributes(from, nil)
-		require.NoError(t, err)
-		require.Len(t, attrs, 5)
+		testAttributeMap(t, map[string]string{
+			"Location":    "Europe",
+			"StorageType": "HDD",
+		}, nil)
 	})
 
 	t.Run("escape characters", func(t *testing.T) {
-		from := []string{
-			`/K\:ey1:V\/alue\\/Ke\/y2:Va\:lue`,
-		}
-		attrs, err := attributes.ParseV2Attributes(from, nil)
-		require.NoError(t, err)
-		require.Equal(t, `K:ey1`, attrs[0].Key())
-		require.Equal(t, `V/alue\`, attrs[0].Value())
-		require.Equal(t, `Ke/y2`, attrs[1].Key())
-		require.Equal(t, `Va:lue`, attrs[1].Value())
-	})
-
-	t.Run("same attributes", func(t *testing.T) {
-		from := []string{"/a:b", "/a:b"}
-		attrs, err := attributes.ParseV2Attributes(from, nil)
-		require.NoError(t, err)
-		require.Len(t, attrs, 1)
-
-		t.Run("with escape characters", func(t *testing.T) {
-			from = []string{`/a\::b\/`, `/a\::b\/`}
-			attrs, err := attributes.ParseV2Attributes(from, nil)
-			require.NoError(t, err)
-			require.Len(t, attrs, 1)
+		testAttributeMap(t, map[string]string{
+			`K\:ey1`: `V\/alue`,
+			`Ke\/y2`: `Va\:lue`,
+		}, map[string]string{
+			`K:ey1`:  `V\/alue`,
+			`Ke\/y2`: `Va:lue`,
 		})
 	})
-
-	t.Run("multiple parents", func(t *testing.T) {
-		from := []string{
-			"/parent1:x/child:x",
-			"/parent2:x/child:x",
-			"/parent2:x/child:x/subchild:x",
-		}
-		attrs, err := attributes.ParseV2Attributes(from, nil)
-		require.NoError(t, err)
-
-		var flag bool
-		for _, attr := range attrs {
-			if attr.Key() == "child" {
-				flag = true
-				require.Equal(t, []string{"parent1", "parent2"}, attr.ParentKeys())
-			}
-		}
-		require.True(t, flag)
-	})
-
-	t.Run("consistent order in chain", func(t *testing.T) {
-		from := []string{"/a:1/b:2/c:3"}
-
-		for i := 0; i < 10000; i++ {
-			attrs, err := attributes.ParseV2Attributes(from, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, "a", attrs[0].Key())
-			require.Equal(t, "1", attrs[0].Value())
-			require.Equal(t, "b", attrs[1].Key())
-			require.Equal(t, "2", attrs[1].Value())
-			require.Equal(t, "c", attrs[2].Key())
-			require.Equal(t, "3", attrs[2].Value())
-		}
-	})
 }