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

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

@@ -7,7 +7,6 @@
 	"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 @@
 	"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/contracts/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 @@
 		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 @@
 	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 @@
 	}
 
 	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 @@
 	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 @@
 	"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 @@
 
 	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 @@
 		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 fmt.Errorf("can't get NNS contract hash: %w", 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 @@
 	"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 @@
 		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 @@
 	}
 	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 @@
 	"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/contracts/nns"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -76,9 +76,9 @@
 		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 @@
 	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 @@
 	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,
 				"[email protected]", 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(),
 				"[email protected]", 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 @@
 			}
 		}
 		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 @@
 	"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/contracts/nns"
+	"github.com/nspcc-dev/neofs-contract/rpc/nns"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -39,76 +39,44 @@
 		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 @@
 	"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 @@
 	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 @@
 			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