adm: never use GetContractStateByID(1) to retrieve NNS hash

And use a bit more of NNS wrapper.

Notice that this changes "alphabet X" to "alphabetX" in dump output, but I
consider this to be an improvement (since that's the contract name).

It also deoptimizes some carefully crafted code to extract a number of names in
one call. Likely it's not a performance issue you care about and it's actually
somewhat broken in that it assumes one result per invocation (but you can get
zero or more than one).

Many more things can be improved, but let's start with this.

Refs. #2826.

Signed-off-by: Roman Khimov <roman@nspcc.ru>

cmd/neofs-adm/internal/modules/morph/balance.go

@@ -7,7 +7,6 @@ import (
 	"math/big"
 
 	"github.com/nspcc-dev/neo-go/pkg/core/native/noderoles"
-	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
 	"github.com/nspcc-dev/neo-go/pkg/encoding/address"
 	"github.com/nspcc-dev/neo-go/pkg/encoding/fixedn"
@@ -19,7 +18,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 	"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
-	"github.com/nspcc-dev/neofs-contract/nns"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	"github.com/nspcc-dev/neofs-sdk-go/netmap"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -42,7 +41,7 @@ func dumpBalances(cmd *cobra.Command, _ []string) error {
 		dumpStorage, _  = cmd.Flags().GetBool(dumpBalancesStorageFlag)
 		dumpAlphabet, _ = cmd.Flags().GetBool(dumpBalancesAlphabetFlag)
 		dumpProxy, _    = cmd.Flags().GetBool(dumpBalancesProxyFlag)
-		nnsCs           *state.Contract
+		nnsReader       *nns.ContractReader
 		nmHash          util.Uint160
 	)
 
@@ -54,12 +53,13 @@ func dumpBalances(cmd *cobra.Command, _ []string) error {
 	inv := invoker.New(c, nil)
 
 	if dumpStorage || dumpAlphabet || dumpProxy {
-		nnsCs, err = c.GetContractStateByID(1)
+		nnsHash, err := nns.InferHash(c)
 		if err != nil {
-			return fmt.Errorf("can't get NNS contract info: %w", err)
+			return fmt.Errorf("can't get NNS contract hash: %w", err)
 		}
+		nnsReader = nns.NewReader(inv, nnsHash)
 
-		nmHash, err = nnsResolveHash(inv, nnsCs.Hash, netmapContract+".neofs")
+		nmHash, err = nnsReader.ResolveFSContract(nns.NameNetmap)
 		if err != nil {
 			return fmt.Errorf("can't get netmap contract hash: %w", err)
 		}
@@ -109,7 +109,7 @@ func dumpBalances(cmd *cobra.Command, _ []string) error {
 	}
 
 	if dumpProxy {
-		h, err := nnsResolveHash(inv, nnsCs.Hash, proxyContract+".neofs")
+		h, err := nnsReader.ResolveFSContract(nns.NameProxy)
 		if err != nil {
 			return fmt.Errorf("can't get hash of the proxy contract: %w", err)
 		}
@@ -124,23 +124,8 @@ func dumpBalances(cmd *cobra.Command, _ []string) error {
 	if dumpAlphabet {
 		alphaList := make([]accBalancePair, len(irList))
 
-		b := smartcontract.NewBuilder()
 		for i := range alphaList {
-			b.InvokeMethod(nnsCs.Hash, "resolve", getAlphabetNNSDomain(i), int64(nns.TXT))
-		}
-
-		script, err := b.Script()
-		if err != nil {
-			return fmt.Errorf("resolving alphabet hashes script: %w", err)
-		}
-
-		alphaRes, err := c.InvokeScript(script, nil)
-		if err != nil {
-			return fmt.Errorf("can't fetch info from NNS: %w", err)
-		}
-
-		for i := range alphaList {
-			h, err := parseNNSResolveResult(alphaRes.Stack[i])
+			h, err := nnsReader.ResolveFSContract(getAlphabetNNSDomain(i))
 			if err != nil {
 				return fmt.Errorf("can't fetch the alphabet contract #%d hash: %w", i, err)
 			}

cmd/neofs-adm/internal/modules/morph/config.go

@@ -14,6 +14,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -28,12 +29,13 @@ func dumpNetworkConfig(cmd *cobra.Command, _ []string) error {
 
 	inv := invoker.New(c, nil)
 
-	cs, err := c.GetContractStateByID(1)
+	nnsHash, err := nns.InferHash(c)
 	if err != nil {
-		return fmt.Errorf("can't get NNS contract info: %w", err)
+		return fmt.Errorf("can't find NNS hash: %w", err)
 	}
+	nnsReader := nns.NewReader(inv, nnsHash)
 
-	nmHash, err := nnsResolveHash(inv, cs.Hash, netmapContract+".neofs")
+	nmHash, err := nnsReader.ResolveFSContract(nns.NameNetmap)
 	if err != nil {
 		return fmt.Errorf("can't get netmap contract hash: %w", err)
 	}
@@ -102,12 +104,13 @@ func setConfigCmd(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("can't initialize context: %w", err)
 	}
 
-	cs, err := wCtx.Client.GetContractStateByID(1)
+	nnsHash, err := nns.InferHash(wCtx.Client)
 	if err != nil {
-		return fmt.Errorf("can't get NNS contract info: %w", err)
+		return err
 	}
+	nnsReader := nns.NewReader(wCtx.ReadOnlyInvoker, nnsHash)
 
-	nmHash, err := nnsResolveHash(wCtx.ReadOnlyInvoker, cs.Hash, netmapContract+".neofs")
+	nmHash, err := nnsReader.ResolveFSContract(nns.NameNetmap)
 	if err != nil {
 		return fmt.Errorf("can't get netmap contract hash: %w", err)
 	}

cmd/neofs-adm/internal/modules/morph/container.go

@@ -13,6 +13,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
 	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -27,13 +28,15 @@ func getContainerContractHash(cmd *cobra.Command, inv *invoker.Invoker, c Client
 		ch, err = util.Uint160DecodeStringLE(s)
 	}
 	if err != nil {
-		nnsCs, err := c.GetContractStateByID(1)
+		nnsHash, err := nns.InferHash(c)
 		if err != nil {
-			return util.Uint160{}, fmt.Errorf("can't get NNS contract state: %w", err)
+			return ch, fmt.Errorf("can't get NNS contract hash: %w", err)
 		}
-		ch, err = nnsResolveHash(inv, nnsCs.Hash, containerContract+".neofs")
+		nnsReader := nns.NewReader(inv, nnsHash)
+
+		ch, err = nnsReader.ResolveFSContract(nns.NameContainer)
 		if err != nil {
-			return util.Uint160{}, err
+			return ch, fmt.Errorf("can't fetch container contract hash: %w", err)
 		}
 	}
 	return ch, nil
@@ -168,12 +171,13 @@ func restoreContainers(cmd *cobra.Command, _ []string) error {
 	}
 	defer wCtx.close()
 
-	nnsCs, err := wCtx.Client.GetContractStateByID(1)
+	nnsHash, err := nns.InferHash(wCtx.Client)
 	if err != nil {
-		return fmt.Errorf("can't get NNS contract state: %w", err)
+		return fmt.Errorf("can't get NNS contract hash: %w", err)
 	}
+	nnsReader := nns.NewReader(wCtx.ReadOnlyInvoker, nnsHash)
 
-	ch, err := nnsResolveHash(wCtx.ReadOnlyInvoker, nnsCs.Hash, containerContract+".neofs")
+	ch, err := nnsReader.ResolveFSContract(nns.NameContainer)
 	if err != nil {
 		return fmt.Errorf("can't fetch container contract hash: %w", err)
 	}

cmd/neofs-adm/internal/modules/morph/deploy.go

@@ -15,7 +15,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
 	"github.com/nspcc-dev/neo-go/pkg/vm/emit"
 	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
-	"github.com/nspcc-dev/neofs-contract/nns"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -76,9 +76,9 @@ func deployContractCmd(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	nnsCs, err := c.Client.GetContractStateByID(1)
+	nnsHash, err := nns.InferHash(c.Client)
 	if err != nil {
-		return fmt.Errorf("can't fetch NNS contract state: %w", err)
+		return fmt.Errorf("can't fetch NNS contract hash: %w", err)
 	}
 
 	callHash := management.Hash
@@ -87,7 +87,7 @@ func deployContractCmd(cmd *cobra.Command, args []string) error {
 	domain := ctrName + "." + zone
 	isUpdate, _ := cmd.Flags().GetBool(updateFlag)
 	if isUpdate {
-		cs.Hash, err = nnsResolveHash(c.ReadOnlyInvoker, nnsCs.Hash, domain)
+		cs.Hash, err = nnsResolveHash(c.ReadOnlyInvoker, nnsHash, domain)
 		if err != nil {
 			return fmt.Errorf("can't fetch contract hash from NNS: %w", err)
 		}
@@ -113,28 +113,28 @@ func deployContractCmd(cmd *cobra.Command, args []string) error {
 	if !isUpdate {
 		bw := io.NewBufBinWriter()
 		emit.Instruction(bw.BinWriter, opcode.INITSSLOT, []byte{1})
-		emit.AppCall(bw.BinWriter, nnsCs.Hash, "getPrice", callflag.All)
+		emit.AppCall(bw.BinWriter, nnsHash, "getPrice", callflag.All)
 		emit.Opcodes(bw.BinWriter, opcode.STSFLD0)
-		emit.AppCall(bw.BinWriter, nnsCs.Hash, "setPrice", callflag.All, 1)
+		emit.AppCall(bw.BinWriter, nnsHash, "setPrice", callflag.All, 1)
 
 		start := bw.Len()
 		needRecord := false
 
-		ok, err := c.nnsRootRegistered(nnsCs.Hash, zone)
+		ok, err := c.nnsRootRegistered(nnsHash, zone)
 		if err != nil {
 			return err
 		} else if !ok {
 			needRecord = true
 
-			emit.AppCall(bw.BinWriter, nnsCs.Hash, "registerTLD", callflag.All,
+			emit.AppCall(bw.BinWriter, nnsHash, "registerTLD", callflag.All,
 				zone,
 				"ops@nspcc.ru", int64(3600), int64(600), int64(defaultExpirationTime), int64(3600))
-			emit.AppCall(bw.BinWriter, nnsCs.Hash, "register", callflag.All,
+			emit.AppCall(bw.BinWriter, nnsHash, "register", callflag.All,
 				domain, c.CommitteeAcc.Contract.ScriptHash(),
 				"ops@nspcc.ru", int64(3600), int64(600), int64(defaultExpirationTime), int64(3600))
 			emit.Opcodes(bw.BinWriter, opcode.ASSERT)
 		} else {
-			s, ok, err := c.nnsRegisterDomainScript(nnsCs.Hash, cs.Hash, domain)
+			s, ok, err := c.nnsRegisterDomainScript(nnsHash, cs.Hash, domain)
 			if err != nil {
 				return err
 			}
@@ -144,17 +144,17 @@ func deployContractCmd(cmd *cobra.Command, args []string) error {
 			}
 		}
 		if needRecord {
-			emit.AppCall(bw.BinWriter, nnsCs.Hash, "deleteRecords", callflag.All, domain, int64(nns.TXT))
-			emit.AppCall(bw.BinWriter, nnsCs.Hash, "addRecord", callflag.All,
-				domain, int64(nns.TXT), address.Uint160ToString(cs.Hash))
+			emit.AppCall(bw.BinWriter, nnsHash, "deleteRecords", callflag.All, domain, nns.TXT)
+			emit.AppCall(bw.BinWriter, nnsHash, "addRecord", callflag.All,
+				domain, nns.TXT, address.Uint160ToString(cs.Hash))
 		}
 
 		if bw.Err != nil {
 			panic(fmt.Errorf("BUG: can't create deployment script: %w", w.Err))
 		} else if bw.Len() != start {
 			w.WriteBytes(bw.Bytes())
 			emit.Opcodes(w.BinWriter, opcode.LDSFLD0, opcode.PUSH1, opcode.PACK)
-			emit.AppCallNoArgs(w.BinWriter, nnsCs.Hash, "setPrice", callflag.All)
+			emit.AppCallNoArgs(w.BinWriter, nnsHash, "setPrice", callflag.All)
 
 			if needRecord {
 				c.Command.Printf("NNS: Set %s -> %s\n", domain, cs.Hash.StringLE())

cmd/neofs-adm/internal/modules/morph/dump_hashes.go

@@ -19,7 +19,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 	"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
-	"github.com/nspcc-dev/neofs-contract/nns"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -39,76 +39,44 @@ func dumpContractHashes(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("can't create N3 client: %w", err)
 	}
 
-	cs, err := c.GetContractStateByID(1)
+	inv := invoker.New(c, nil)
+	nnsHash, err := nns.InferHash(c)
 	if err != nil {
-		return err
+		return fmt.Errorf("can't get NNS contract hash: %w", err)
 	}
+	nnsReader := nns.NewReader(inv, nnsHash)
 
 	zone, _ := cmd.Flags().GetString(customZoneFlag)
 	if zone != "" {
-		return dumpCustomZoneHashes(cmd, cs.Hash, zone, c)
+		return dumpCustomZoneHashes(cmd, nnsHash, zone, c)
 	}
 
-	infos := []contractDumpInfo{{name: nnsContract, hash: cs.Hash}}
+	infos := []contractDumpInfo{{name: nnsContract, hash: nnsHash}}
 
 	irSize := 0
 	for ; irSize < lastGlagoliticLetter; irSize++ {
-		ok, err := nnsIsAvailable(c, cs.Hash, getAlphabetNNSDomain(irSize))
+		ok, err := nnsReader.IsAvailable(getAlphabetNNSDomain(irSize) + "." + nns.ContractTLD)
 		if err != nil {
 			return err
 		} else if ok {
 			break
 		}
 	}
 
-	b := smartcontract.NewBuilder()
-
-	if irSize != 0 {
-		b.Reset()
-		for i := 0; i < irSize; i++ {
-			b.InvokeMethod(cs.Hash, "resolve", getAlphabetNNSDomain(i), int64(nns.TXT))
-		}
-
-		script, err := b.Script()
-		if err != nil {
-			return fmt.Errorf("resolving alphabet hashes script: %w", err)
-		}
-
-		alphaRes, err := c.InvokeScript(script, nil)
-		if err != nil {
-			return fmt.Errorf("can't fetch info from NNS: %w", err)
-		}
-
-		for i := 0; i < irSize; i++ {
-			info := contractDumpInfo{name: fmt.Sprintf("alphabet %d", i)}
-			if h, err := parseNNSResolveResult(alphaRes.Stack[i]); err == nil {
-				info.hash = h
-			}
-			infos = append(infos, info)
-		}
+	var contracts = make([]string, 0, irSize+len(contractList))
+	for i := 0; i < irSize; i++ {
+		contracts = append(contracts, getAlphabetNNSDomain(i))
 	}
-
 	for _, ctrName := range contractList {
-		b.Reset()
-		b.InvokeMethod(cs.Hash, "resolve", ctrName+".neofs", int64(nns.TXT))
-
-		script, err := b.Script()
-		if err != nil {
-			return fmt.Errorf("resolving neofs contract hashes script: %w", err)
-		}
+		contracts = append(contracts, ctrName)
+	}
 
-		res, err := c.InvokeScript(script, nil)
+	for _, ctrName := range contracts {
+		h, err := nnsReader.ResolveFSContract(ctrName)
 		if err != nil {
-			return fmt.Errorf("can't fetch info from NNS: %w", err)
-		}
-
-		info := contractDumpInfo{name: ctrName}
-		if len(res.Stack) != 0 {
-			if h, err := parseNNSResolveResult(res.Stack[0]); err == nil {
-				info.hash = h
-			}
+			return fmt.Errorf("can't resolve %s contract: %w", ctrName, err)
 		}
-		infos = append(infos, info)
+		infos = append(infos, contractDumpInfo{name: ctrName, hash: h})
 	}
 
 	fillContractVersion(cmd, c, infos)

cmd/neofs-adm/internal/modules/morph/dump_names.go

@@ -9,7 +9,7 @@ import (
 	"time"
 
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker"
-	"github.com/nspcc-dev/neo-go/pkg/rpcclient/nep11"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -28,12 +28,12 @@ func dumpNames(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return fmt.Errorf("can't create N3 client: %w", err)
 	}
-	cs, err := c.GetContractStateByID(1) // NNS.
+	nnsHash, err := nns.InferHash(c)
 	if err != nil {
 		return err
 	}
-	var n11r = nep11.NewNonDivisibleReader(invoker.New(c, nil), cs.Hash)
-	tokIter, err := n11r.Tokens()
+	var nnsReader = nns.NewReader(invoker.New(c, nil), nnsHash)
+	tokIter, err := nnsReader.Tokens()
 	if err != nil {
 		return err
 	}
@@ -48,7 +48,7 @@ func dumpNames(cmd *cobra.Command, _ []string) error {
 			if zone != "" && !strings.HasSuffix(name, "."+zone) {
 				continue
 			}
-			props, err := n11r.Properties(toks[i])
+			props, err := nnsReader.Properties(toks[i])
 			if err != nil {
 				cmd.PrintErrf("Error getting properties for %s: %v\n", name, err)
 				continue